feat: format-aware price table — Platform|Format|Price|Buy in bot chat

Expand catalog offers to one row per format from format_prices so visitors
see which amount is Hardcover vs eBook vs Audiobook. Add format_clarify
short-circuit for follow-ups like 'are those hardcover or audiobook'.
Widget grid is 4 columns; Telegram labels include format; cheapest/how-much
still use a single Buy CTA but name the format in prose (R-PI-005/006).

Co-authored-by: Cursor <cursoragent@cursor.com>

.agent/BDD_SPECS.md

@@ -1118,14 +1118,28 @@ Feature: Bot price intelligence (grounded catalog)
     Given a book has verified Amazon and Kobo listings with URLs
     When the visitor asks "list all platforms with prices"
     Then intent is price_inquiry
-    And the response includes platform_offers with Platform Price Buy rows
+    And the response includes platform_offers with Platform Format Price Buy rows
     And bot text has no markdown table
 
-  Scenario: Cheapest highlights best offer
+  Scenario: List expands one row per format
+    Given Amazon has format_prices Hardcover $35 and eBook $14.99 and Apple has eBook $14.99
+    When the visitor asks "list all platforms with prices"
+    Then platform_offers includes Amazon Hardcover $35.00 and Amazon eBook $14.99 and Apple Books eBook $14.99
+    And every priced row names its format
+
+  Scenario: Format clarify returns grounded table
+    Given the visitor already saw a price list for the selected book
+    When the visitor asks "are those hardcover or audiobook"
+    Then intent is price_inquiry
+    And the reply does not guess formats
+    And platform_offers shows each stored format with its price
+
+  Scenario: Cheapest names format and uses single Buy CTA
     Given Amazon eBook is $14.99 and Kobo eBook is $9.99 both verified
     When the visitor asks "where is it cheapest"
-    Then the reply names Kobo and $9.99
-    And the Kobo platform_offers row has is_best true
+    Then the reply names Kobo and $9.99 and eBook
+    And platform_offers is absent
+    And a Buy on Kobo link is shown
 
   Scenario: Soft too-expensive uses grounded PRICE_FACTS
     Given a book has a grounded source price of $14.99

.agent/FILE_MAP.md

@@ -110,7 +110,7 @@
 | `app/services/book_service.py` | Admin book CRUD, covers, URL import, platform presence |
 | `app/services/platform_catalog.py` | Canonical format prices + listing view for admin/bot |
 | `app/services/price_catalog_service.py` | Grounded visitor price answers + platform_offers payload |
-| `.agent/PRICE_INTELLIGENCE_RULES.md` | Bot price intelligence rules (R-PI-001–004) |
+| `.agent/PRICE_INTELLIGENCE_RULES.md` | Bot price intelligence rules (R-PI-001–006, format-aware grid) |
 | `app/services/admin_analytics_service.py` | Admin dashboard analytics (funnel, heatmap, visitors) |
 | `app/services/dashboard_service.py` | Dashboard stats, session moderation, transcripts |
 | `app/services/ingestion_service.py` | File + text ingestion pipeline, upload orchestration |

.agent/PRICE_INTELLIGENCE_RULES.md

@@ -1,11 +1,11 @@
 # Feature Rules — Bot Price Intelligence
 
 > Grounded retailer prices for visitor chat. Never invent dollars.
-> Structured Platform / Price / Buy UI — not markdown tables (R-068).
+> Structured Platform / Format / Price / Buy UI — not markdown tables (R-068).
 
 ## 1. Problem & scope
 
-- **User story:** Visitors ask price questions (how much, cheapest, compare, list all platforms, buy link for X). The bot answers from stored `book_platform_listings` and shows a 3-column buy UI when listing retailers.
+- **User story:** Visitors ask price questions (how much, cheapest, compare, list all platforms, format clarify, buy link for X). The bot answers from stored `book_platform_listings` and shows a 4-column buy UI when listing retailers.
 - **In scope:**
   - `price_inquiry` intent for list / cheapest / expensive / compare / platform-link
   - Deterministic `PriceCatalogService` answers (no LLM for factual price turns)
@@ -46,10 +46,11 @@ No new endpoints.
 
 ## 5. UI
 
-- **Widget:** 3-column grid Platform | Price | Buy under bot bubble — **only** for list-all / compare turns
-- **Single-winner turns** (cheapest, most expensive, how much, buy link for X): text + one Buy button; no grid
+- **Widget:** 4-column grid Platform | Format | Price | Buy under bot bubble — for list-all / compare / format_clarify (and multi-format how-much on one platform)
+- **Single-winner turns** (cheapest, most expensive, single-format how much / buy link): text + one Buy button; no grid; sentence **names format** when known
+- **Empty format:** display `—` in Format column; never invent Hardcover/eBook/Audiobook
 - **Empty price:** display `See site`; Buy uses that platform's `listing_url`
-- **Telegram:** stacked URL buttons (`Platform — $x.xx`), max 4
+- **Telegram:** stacked URL buttons (`Amazon Hardcover — $35.00`), max 4
 
 ## 6. Priority / fallback
 
@@ -80,3 +81,5 @@ No new endpoints.
 - **R-PI-002:** List-all uses `platform_offers`, never markdown tables
 - **R-PI-003:** Factual price turns skip RAG/LLM
 - **R-PI-004:** Multi-book: book picker before price short-circuit
+- **R-PI-005:** Never quote a dollar without naming its format when `format_prices` has it; list grid is Platform | Format | Price | Buy
+- **R-PI-006:** `catalog_for_book` emits one Offer per priced format; format_clarify is deterministic (no LLM)

app/channels/adapters/telegram.py

@@ -157,15 +157,17 @@ def inline_keyboard_for_platform_offers(
     *,
     max_buttons: int = 4,
 ) -> dict[str, Any] | None:
-    """Map platform_offers rows to stacked URL buttons (Platform — price)."""
+    """Map platform_offers rows to stacked URL buttons (Platform Format — price)."""
     rows: list[list[dict[str, str]]] = []
     for offer in (offers or [])[:max_buttons]:
         url = (offer.get("url") or "").strip()
         if not url.startswith(("http://", "https://")):
             continue
         platform = (offer.get("platform") or "Store").strip() or "Store"
+        fmt = (offer.get("format") or "").strip()
         price = (offer.get("price") or "").strip()
-        label = f"{platform} — {price}" if price else platform
+        name = f"{platform} {fmt}".strip() if fmt else platform
+        label = f"{name} — {price}" if price else name
         rows.append([{"text": label[:64], "url": url}])
     if not rows:
         return None

app/channels/services/bot_bridge.py

@@ -281,8 +281,10 @@ async def generate_channel_reply(
                 if not url.startswith(("http://", "https://")):
                     continue
                 platform = (o.get("platform") or "Store").strip()
+                fmt = (o.get("format") or "").strip()
                 price = (o.get("price") or "").strip()
-                label = f"{platform} — {price}" if price else f"Buy on {platform}"
+                name = f"{platform} {fmt}".strip() if fmt else platform
+                label = f"{name} — {price}" if price else f"Buy on {name}"
                 links.append({
                     "label": label[:64],
                     "url": url,
@@ -290,19 +292,24 @@ async def generate_channel_reply(
                     "icon": "🛒",
                 })
         elif offers and links:
-            # Append remaining offer URLs (skip duplicates) up to 4 total buttons.
+            # Append remaining offer rows (allow same URL when format label differs).
             for o in offers:
                 if len(links) >= 4:
                     break
                 url = (o.get("url") or "").strip()
                 if not url.startswith(("http://", "https://")):
                     continue
-                if any((lnk.get("url") or "") == url for lnk in links):
-                    continue
                 platform = (o.get("platform") or "Store").strip()
+                fmt = (o.get("format") or "").strip()
                 price = (o.get("price") or "").strip()
+                name = f"{platform} {fmt}".strip() if fmt else platform
+                label = (f"{name} — {price}" if price else name)[:64]
+                if any((lnk.get("label") or "") == label for lnk in links):
+                    continue
+                if not fmt and any((lnk.get("url") or "") == url for lnk in links):
+                    continue
                 links.append({
-                    "label": (f"{platform} — {price}" if price else platform)[:64],
+                    "label": label,
                     "url": url,
                     "type": "platform_purchase",
                     "icon": "🛒",

app/schemas/chatbot.py

@@ -20,10 +20,11 @@ class LinkItem(BaseModel):
 
 
 class PlatformOfferItem(BaseModel):
-    """One retailer row for the widget Platform | Price | Buy grid."""
+    """One retailer+format row for the widget Platform | Format | Price | Buy grid."""
 
     platform_id: str
     platform: str
+    format: str = ""
     price: str
     url: str
     is_best: bool = False

app/services/intent.py

@@ -94,6 +94,11 @@ _PRICE_INQUIRY_SIGNALS: tuple[str, ...] = (
     "buy link for", "purchase link for", "how much on amazon", "how much on kobo",
     "buy on amazon", "buy on kobo", "buy on barnes",
     "which platforms", "where can i get it cheapest",
+    "which format", "what format", "hard copy",
+    "hardcover or", "audiobook or", "ebook or", "paperback or",
+    "are those hardcover", "are these hardcover",
+    "are those audiobook", "are these audiobook",
+    "are those ebook", "are these ebook",
 )
 
 _PURCHASE_SIGNALS: tuple[str, ...] = (

app/services/price_catalog_service.py

@@ -1,7 +1,8 @@
-"""Grounded retailer price answers for visitor chat (R-PI-001–004).
+"""Grounded retailer price answers for visitor chat (R-PI-001–006).
 
 Reads ``book_platform_listings`` only. Never invents dollar amounts.
-Factual price turns return structured ``platform_offers`` for the widget grid.
+Factual price turns return structured ``platform_offers`` for the widget grid
+(Platform | Format | Price | Buy — one row per platform+format).
 """
 
 from __future__ import annotations
@@ -17,11 +18,18 @@ from app.services.book_url_scraper import PLATFORM_DISPLAY
 from app.services.platform_catalog import (
     BOT_CHAT_EXCLUDED_PLATFORMS,
     canonical_format_prices,
-    primary_list_price,
 )
 
 _PRICE_RE = re.compile(r"\$?\s*([0-9]+(?:\.[0-9]{1,2})?)")
 
+_FORMAT_ORDER = (
+    "Hardcover",
+    "Paperback",
+    "Mass Market Paperback",
+    "eBook",
+    "Audiobook",
+)
+
 _PLATFORM_ALIASES: dict[str, tuple[str, ...]] = {
     "amazon": ("amazon", "kindle", "audible"),
     "barnes_noble": ("barnes", "b&n", "bn.com", "nook"),
@@ -38,6 +46,8 @@ _PLATFORM_ALIASES: dict[str, tuple[str, ...]] = {
 _FORMAT_HINTS: tuple[tuple[str, str], ...] = (
     ("hardcover", "Hardcover"),
     ("hard cover", "Hardcover"),
+    ("hard copy", "Hardcover"),
+    ("hardcopy", "Hardcover"),
     ("paperback", "Paperback"),
     ("mass market", "Mass Market Paperback"),
     ("ebook", "eBook"),
@@ -50,7 +60,7 @@ _FORMAT_HINTS: tuple[tuple[str, str], ...] = (
 
 @dataclass(frozen=True)
 class Offer:
-    """One retailer offer for chat / widget."""
+    """One retailer + format offer for chat / widget."""
 
     platform_id: str
     platform: str
@@ -58,13 +68,14 @@ class Offer:
     price_cents: int | None
     url: str
     is_source: bool = False
+    format: str = ""
 
 
 @dataclass(frozen=True)
 class PriceQuery:
     """Classified price question."""
 
-    kind: str  # list|cheapest|expensive|compare|platform_link|how_much|soft_value|none
+    kind: str  # list|cheapest|expensive|compare|platform_link|how_much|format_clarify|soft_value|none
     platform_ids: tuple[str, ...] = ()
     format_hint: str = ""
 
@@ -114,6 +125,16 @@ def classify_price_query(message: str) -> PriceQuery:
     if any(s in q for s in soft):
         return PriceQuery(kind="soft_value", platform_ids=platforms, format_hint=fmt)
 
+    clarify = (
+        "hardcover or", "hard cover or", "hard copy or", "audiobook or",
+        "ebook or", "e-book or", "paperback or",
+        "which format", "what format", "are those", "are these",
+        "is that the", "is that hardcover", "is that audiobook",
+        "is that ebook", "format are", "those prices",
+    )
+    if any(s in q for s in clarify):
+        return PriceQuery(kind="format_clarify", platform_ids=platforms, format_hint=fmt)
+
     list_sigs = (
         "list all platforms", "all platforms", "all prices", "all retailers",
         "platform prices", "formats and prices", "every platform",
@@ -153,19 +174,25 @@ def classify_price_query(message: str) -> PriceQuery:
     return PriceQuery(kind="none", platform_ids=platforms, format_hint=fmt)
 
 
-def format_price_facts(offers: list[Offer], limit: int = 4) -> str:
+def _format_clause(offer: Offer) -> str:
+    """Parenthetical format for prose when known."""
+    return f" ({offer.format})" if offer.format else ""
+
+
+def format_price_facts(offers: list[Offer], limit: int = 6) -> str:
     """Build PRICE_FACTS snippet for soft objection LLM turns."""
     lines: list[str] = []
     for o in offers[:limit]:
         if o.price_cents is None:
             continue
         src = " (source)" if o.is_source else ""
-        lines.append(f"{o.platform}{src}: {o.price_display}")
+        fmt = f" {o.format}" if o.format else ""
+        lines.append(f"{o.platform}{fmt}{src}: {o.price_display}")
     if not lines:
         return ""
     return (
-        "PRICE_FACTS (cite ONLY these exact amounts; never invent other prices; "
-        "never paste URLs — buttons handle purchase):\n- "
+        "PRICE_FACTS (cite ONLY these exact amounts and formats; never invent "
+        "other prices or formats; never paste URLs — buttons handle purchase):\n- "
         + "\n- ".join(lines)
     )
 
@@ -175,6 +202,7 @@ def offer_to_platform_item(offer: Offer, *, is_best: bool = False) -> dict[str,
     return {
         "platform_id": offer.platform_id,
         "platform": offer.platform,
+        "format": offer.format or "",
         "price": offer.price_display or "See site",
         "url": offer.url,
         "is_best": is_best,
@@ -195,7 +223,7 @@ class PriceCatalogService:
         *,
         format_hint: str = "",
     ) -> list[Offer]:
-        """Return verified offers with a buy URL for one book."""
+        """Return one offer per priced format (or one list_price fallback row)."""
         rows = await self._listings.list_for_book(book_id, author_id)
         offers: list[Offer] = []
         for row in rows:
@@ -211,21 +239,39 @@ class PriceCatalogService:
                 row.format_prices if isinstance(getattr(row, "format_prices", None), dict) else {},
                 pid,
             )
-            display = primary_list_price(
-                fps,
-                format_hint or (getattr(row, "book_format", None) or ""),
-                getattr(row, "list_price", None) or "",
-            )
-            if not display and format_hint and fps.get(format_hint):
-                display = fps[format_hint]
-            cents = parse_price_cents(display)
+            display_name = PLATFORM_DISPLAY.get(pid, pid.replace("_", " ").title())
+            is_source = bool(getattr(row, "is_source", False))
+
+            if fps:
+                for fmt_key in _FORMAT_ORDER:
+                    if fmt_key not in fps:
+                        continue
+                    if format_hint and fmt_key != format_hint:
+                        continue
+                    display = fps[fmt_key]
+                    offers.append(Offer(
+                        platform_id=pid,
+                        platform=display_name,
+                        price_display=display,
+                        price_cents=parse_price_cents(display),
+                        url=url,
+                        is_source=is_source,
+                        format=fmt_key,
+                    ))
+                continue
+
+            list_price = (getattr(row, "list_price", None) or "").strip()
+            if format_hint:
+                # No format map — cannot claim the hint; skip this row.
+                continue
             offers.append(Offer(
                 platform_id=pid,
-                platform=PLATFORM_DISPLAY.get(pid, pid.replace("_", " ").title()),
-                price_display=display if display else "See site",
-                price_cents=cents,
+                platform=display_name,
+                price_display=list_price if list_price else "See site",
+                price_cents=parse_price_cents(list_price),
                 url=url,
-                is_source=bool(getattr(row, "is_source", False)),
+                is_source=is_source,
+                format="",
             ))
         return offers
 
@@ -238,14 +284,18 @@ class PriceCatalogService:
     ) -> dict[str, Any]:
         """Build a full chat response dict for a factual price turn."""
         pq = classify_price_query(query)
+        # format_clarify must show every stored format — ignore incidental hint words.
+        hint = "" if pq.kind == "format_clarify" else pq.format_hint
         offers = await self.catalog_for_book(
-            author_id, book_id, format_hint=pq.format_hint,
+            author_id, book_id, format_hint=hint,
         )
         if not offers:
             return await self._build_empty_fallback(author_id, book_id, book_title)
 
         kind = pq.kind
-        if kind == "list":
+        if kind in ("list", "format_clarify", "none"):
+            if kind == "format_clarify":
+                return self._build_format_clarify_answer(offers, book_title)
             return self._build_list_answer(offers, book_title)
         if kind == "cheapest":
             return self._build_cheapest_answer(offers, book_title)
@@ -257,7 +307,6 @@ class PriceCatalogService:
             return self._build_platform_link_answer(offers, book_title, pq.platform_ids)
         if kind == "how_much":
             return self._build_how_much_answer(offers, book_title, pq.platform_ids)
-        # soft_value / none should not call handle — fall through to list as safe default
         return self._build_list_answer(offers, book_title)
 
     async def _build_empty_fallback(
@@ -280,11 +329,12 @@ class PriceCatalogService:
         )
 
     def _build_list_answer(self, offers: list[Offer], book_title: str) -> dict[str, Any]:
-        """All verified platforms as platform_offers grid (no duplicate pills)."""
+        """All verified platform+format rows as platform_offers grid."""
         priced = sum(1 for o in offers if o.price_cents is not None)
         text = (
             f"Here are the places I know for {book_title} — "
-            f"{priced} with a listed price. Pick a Buy button for the store you prefer."
+            f"{priced} with a listed price and format. "
+            "Pick a Buy button for the store and format you prefer."
         )
         return {
             "text": text,
@@ -293,6 +343,30 @@ class PriceCatalogService:
             "platform_offers": [offer_to_platform_item(o) for o in offers],
         }
 
+    def _build_format_clarify_answer(
+        self, offers: list[Offer], book_title: str,
+    ) -> dict[str, Any]:
+        """Re-list every stored price with its format — no guessing."""
+        formats = sorted({o.format for o in offers if o.format})
+        if formats:
+            named = ", ".join(formats)
+            text = (
+                f"Here’s each listed price for {book_title} with its format "
+                f"({named}). I only show formats I have stored — nothing invented."
+            )
+        else:
+            text = (
+                f"Here are the listed prices I have for {book_title}. "
+                "I don��t have separate format labels for these yet — "
+                "check the retailer page for binding details."
+            )
+        return {
+            "text": text[:380],
+            "links": [],
+            "has_links": False,
+            "platform_offers": [offer_to_platform_item(o) for o in offers],
+        }
+
     def _build_cheapest_answer(self, offers: list[Offer], book_title: str) -> dict[str, Any]:
         priced = [o for o in offers if o.price_cents is not None]
         if len(priced) < 1:
@@ -308,9 +382,8 @@ class PriceCatalogService:
         best = min(priced, key=lambda o: o.price_cents or 10**9)
         text = (
             f"The lowest listed price for {book_title} is {best.price_display} "
-            f"on {best.platform}."
+            f"on {best.platform}{_format_clause(best)}."
         )
-        # Single winner + Buy button only — no full Platform/Price/Buy grid.
         return {
             "text": text,
             "links": [{
@@ -330,7 +403,7 @@ class PriceCatalogService:
         top = max(priced, key=lambda o: o.price_cents or 0)
         text = (
             f"The highest listed price for {book_title} is {top.price_display} "
-            f"on {top.platform}."
+            f"on {top.platform}{_format_clause(top)}."
         )
         return {
             "text": text,
@@ -352,10 +425,10 @@ class PriceCatalogService:
     ) -> dict[str, Any]:
         selected = [o for o in offers if o.platform_id in platform_ids] if platform_ids else list(offers)
         if len(selected) < 2:
-            selected = list(offers)[:4]
+            selected = list(offers)[:6]
         bits = []
         for o in selected:
-            bits.append(f"{o.platform} at {o.price_display}")
+            bits.append(f"{o.platform}{_format_clause(o)} at {o.price_display}")
         text = f"For {book_title}: " + "; ".join(bits) + "."
         return {
             "text": text[:380],
@@ -370,9 +443,23 @@ class PriceCatalogService:
         book_title: str,
         platform_ids: tuple[str, ...],
     ) -> dict[str, Any]:
-        # Visitor named a catalog-only site (e.g. Google Books) — redirect to retailers.
         named_excluded = [p for p in platform_ids if p in BOT_CHAT_EXCLUDED_PLATFORMS]
         retail_ids = [p for p in platform_ids if p not in BOT_CHAT_EXCLUDED_PLATFORMS]
+
+        if retail_ids:
+            platform_rows = [o for o in offers if o.platform_id in retail_ids]
+            if len(platform_rows) > 1:
+                name = platform_rows[0].platform
+                text = (
+                    f"On {name}, here are the format prices I have for {book_title}."
+                )
+                return {
+                    "text": text[:380],
+                    "links": [],
+                    "has_links": False,
+                    "platform_offers": [offer_to_platform_item(o) for o in platform_rows],
+                }
+
         target = None
         for pid in retail_ids:
             for o in offers:
@@ -388,7 +475,7 @@ class PriceCatalogService:
             target = next((o for o in offers if o.is_source), offers[0])
             text = (
                 f"I don't use {excl_name} as a buy link for {book_title} — "
-                f"here's {target.platform} instead"
+                f"here's {target.platform}{_format_clause(target)} instead"
                 + (f" at {target.price_display}." if target.price_cents is not None else ".")
             )
             return {
@@ -411,7 +498,8 @@ class PriceCatalogService:
             )
         else:
             text = (
-                f"{book_title} is listed at {target.price_display} on {target.platform}."
+                f"{book_title} is listed at {target.price_display} "
+                f"on {target.platform}{_format_clause(target)}."
             )
         return {
             "text": text,
@@ -433,7 +521,21 @@ class PriceCatalogService:
     ) -> dict[str, Any]:
         if platform_ids:
             return self._build_platform_link_answer(offers, book_title, platform_ids)
-        source = next((o for o in offers if o.is_source), None)
+
+        source_rows = [o for o in offers if o.is_source]
+        if len(source_rows) > 1:
+            name = source_rows[0].platform
+            text = (
+                f"On {name}, here are the format prices I have for {book_title}."
+            )
+            return {
+                "text": text[:380],
+                "links": [],
+                "has_links": False,
+                "platform_offers": [offer_to_platform_item(o) for o in source_rows],
+            }
+
+        source = source_rows[0] if source_rows else None
         priced = [o for o in offers if o.price_cents is not None]
         target = source if source and source.price_cents is not None else (
             min(priced, key=lambda o: o.price_cents or 10**9) if priced else (source or offers[0])
@@ -446,7 +548,7 @@ class PriceCatalogService:
         else:
             text = (
                 f"{book_title} is listed at {target.price_display} "
-                f"on {target.platform}."
+                f"on {target.platform}{_format_clause(target)}."
             )
         return {
             "text": text,

static/widget.js

@@ -199,8 +199,8 @@
       background: ${T.surface}; overflow: hidden;
     }
     .ab-po-header, .ab-po-row {
-      display: grid; grid-template-columns: 1.2fr 0.8fr auto;
-      gap: 8px; align-items: center; padding: 8px 10px;
+      display: grid; grid-template-columns: 1.1fr 0.9fr 0.7fr auto;
+      gap: 6px; align-items: center; padding: 8px 10px;
       font-size: 12px;
     }
     .ab-po-header {
@@ -212,6 +212,7 @@
     .ab-po-row:last-child { border-bottom: none; }
     .ab-po-row.ab-po-best { background: ${T.brand}12; }
     .ab-po-row .ab-link-btn { padding: 4px 10px; font-size: 11px; }
+    .ab-po-fmt { color: ${T.sub}; font-size: 11px; }
 
     .ab-followups { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 8px; max-width: 100%; }
     .ab-followup-chip {
@@ -788,11 +789,13 @@
       }
 
       if (platformOffers && platformOffers.length) {
-        html += `<div class="ab-platform-offers"><div class="ab-po-header"><span>Platform</span><span>Price</span><span>Buy</span></div>`;
+        html += `<div class="ab-platform-offers"><div class="ab-po-header"><span>Platform</span><span>Format</span><span>Price</span><span>Buy</span></div>`;
         platformOffers.forEach(o => {
           const best = o.is_best ? ' ab-po-best' : '';
+          const fmt = (o.format || '').trim() || '—';
           html += `<div class="ab-po-row${best}">
             <span>${escHtml(o.platform || '')}</span>
+            <span class="ab-po-fmt">${escHtml(fmt)}</span>
             <span>${escHtml(o.price || 'See site')}</span>
             <a class="ab-link-btn" href="${escAttr(o.url)}" target="_blank" rel="noopener"
                data-type="platform_purchase" data-platform="${escAttr(o.platform_id || '')}">Buy</a>

tests/bdd/features/price_intelligence.feature

@@ -8,3 +8,8 @@ Feature: Bot price intelligence
   Scenario: Soft too expensive stays purchase path
     Given a visitor message "that's too expensive"
     Then price query kind is soft_value
+
+  Scenario: Format clarify is price_inquiry
+    Given a visitor message "are those hardcover or audiobook"
+    Then intent classification returns price_inquiry
+    And price query kind is format_clarify

tests/bdd/steps/price_intelligence_steps.py

@@ -21,3 +21,8 @@ def step_intent_price_inquiry(context):
 @then("price query kind is soft_value")
 def step_soft_value(context):
     assert classify_price_query(context.visitor_message).kind == "soft_value"
+
+
+@then("price query kind is format_clarify")
+def step_format_clarify(context):
+    assert classify_price_query(context.visitor_message).kind == "format_clarify"

tests/unit/test_price_catalog_service.py

@@ -33,6 +33,9 @@ def test_classify_price_query_kinds():
     assert classify_price_query("buy link for amazon").kind == "platform_link"
     assert classify_price_query("how much does it cost").kind == "how_much"
     assert classify_price_query("that's too expensive").kind == "soft_value"
+    assert classify_price_query("are those hardcover or audiobook").kind == "format_clarify"
+    assert classify_price_query("which format is the $35").kind == "format_clarify"
+    assert classify_price_query("cheapest ebook").format_hint == "eBook"
 
 
 def test_price_inquiry_intent_before_purchase():
@@ -40,16 +43,18 @@ def test_price_inquiry_intent_before_purchase():
     assert "cheapest" not in _PURCHASE_SIGNALS
     assert _classify_by_rules("where is it cheapest") == "price_inquiry"
     assert _classify_by_rules("list all platforms") == "price_inquiry"
+    assert _classify_by_rules("are those hardcover or audiobook") == "price_inquiry"
     assert _classify_by_rules("how much does it cost") == "purchase_intent"
 
 
 def test_format_price_facts_only_priced():
     offers = [
-        Offer("amazon", "Amazon", "$14.99", 1499, "https://a", True),
-        Offer("kobo", "Kobo", "See site", None, "https://k", False),
+        Offer("amazon", "Amazon", "$14.99", 1499, "https://a", True, "eBook"),
+        Offer("kobo", "Kobo", "See site", None, "https://k", False, ""),
     ]
     facts = format_price_facts(offers)
     assert "$14.99" in facts
+    assert "eBook" in facts
     assert "See site" not in facts
     assert "PRICE_FACTS" in facts
 
@@ -63,14 +68,16 @@ def test_chat_response_accepts_platform_offers():
             PlatformOfferItem(
                 platform_id="amazon",
                 platform="Amazon",
-                price="$14.99",
+                format="Hardcover",
+                price="$35.00",
                 url="https://amazon.com/dp/X",
                 is_best=True,
             ),
         ],
     )
     dumped = resp.model_dump()
-    assert dumped["platform_offers"][0]["price"] == "$14.99"
+    assert dumped["platform_offers"][0]["price"] == "$35.00"
+    assert dumped["platform_offers"][0]["format"] == "Hardcover"
     assert dumped["platform_offers"][0]["is_best"] is True
 
 
@@ -87,12 +94,13 @@ def test_get_book_links_still_ignores_platform_listings():
 async def test_build_cheapest_marks_is_best():
     svc = PriceCatalogService.__new__(PriceCatalogService)
     offers = [
-        Offer("amazon", "Amazon", "$14.99", 1499, "https://a.com", True),
-        Offer("kobo", "Kobo", "$9.99", 999, "https://k.com", False),
+        Offer("amazon", "Amazon", "$14.99", 1499, "https://a.com", True, "eBook"),
+        Offer("kobo", "Kobo", "$9.99", 999, "https://k.com", False, "eBook"),
     ]
     result = svc._build_cheapest_answer(offers, "Lethal Lines")
     assert "Kobo" in result["text"]
     assert "$9.99" in result["text"]
+    assert "eBook" in result["text"]
     assert result["platform_offers"] is None
     assert result["links"][0]["url"] == "https://k.com"
     assert "Buy on Kobo" in result["links"][0]["label"]
@@ -102,7 +110,7 @@ async def test_build_cheapest_marks_is_best():
 async def test_google_books_link_ask_redirects_to_retail():
     svc = PriceCatalogService.__new__(PriceCatalogService)
     offers = [
-        Offer("amazon", "Amazon", "$14.99", 1499, "https://a.com", True),
+        Offer("amazon", "Amazon", "$14.99", 1499, "https://a.com", True, "eBook"),
     ]
     result = svc._build_platform_link_answer(offers, "Lethal Lines", ("google_books",))
     assert "Google Books" in result["text"]
@@ -115,13 +123,65 @@ async def test_google_books_link_ask_redirects_to_retail():
 async def test_build_list_see_site_for_unpriced():
     svc = PriceCatalogService.__new__(PriceCatalogService)
     offers = [
-        Offer("amazon", "Amazon", "See site", None, "https://a.com", True),
-        Offer("kobo", "Kobo", "$9.99", 999, "https://k.com", False),
+        Offer("amazon", "Amazon", "See site", None, "https://a.com", True, ""),
+        Offer("kobo", "Kobo", "$9.99", 999, "https://k.com", False, "eBook"),
     ]
     result = svc._build_list_answer(offers, "Book")
     assert result["links"] == []
     assert len(result["platform_offers"]) == 2
     assert result["platform_offers"][0]["price"] == "See site"
+    assert result["platform_offers"][1]["format"] == "eBook"
+
+
+@pytest.mark.asyncio
+async def test_format_clarify_returns_grid():
+    svc = PriceCatalogService.__new__(PriceCatalogService)
+    offers = [
+        Offer("amazon", "Amazon", "$35.00", 3500, "https://a.com", True, "Hardcover"),
+        Offer("amazon", "Amazon", "$14.99", 1499, "https://a.com", True, "eBook"),
+        Offer("apple_books", "Apple Books", "$14.99", 1499, "https://apple.com", False, "eBook"),
+    ]
+    result = svc._build_format_clarify_answer(offers, "All We Say")
+    assert "format" in result["text"].lower()
+    assert len(result["platform_offers"]) == 3
+    assert result["platform_offers"][0]["format"] == "Hardcover"
+    assert result["links"] == []
+
+
+@pytest.mark.asyncio
+async def test_catalog_for_book_expands_formats():
+    svc = PriceCatalogService(MagicMock())
+    svc._listings = MagicMock()
+    svc._listings.list_for_book = AsyncMock(return_value=[
+        SimpleNamespace(
+            status="verified",
+            listing_url="https://amazon.com/dp/B0X",
+            platform_id="amazon",
+            format_prices={"Hardcover": "$35.00", "eBook": "$14.99"},
+            list_price="$35.00",
+            book_format="Hardcover",
+            is_source=True,
+        ),
+        SimpleNamespace(
+            status="verified",
+            listing_url="https://books.apple.com/us/book/x",
+            platform_id="apple_books",
+            format_prices={"eBook": "$14.99"},
+            list_price="$14.99",
+            book_format="eBook",
+            is_source=False,
+        ),
+    ])
+    offers = await svc.catalog_for_book("a1", "b1")
+    assert len(offers) == 3
+    assert {(o.platform_id, o.format, o.price_display) for o in offers} == {
+        ("amazon", "Hardcover", "$35.00"),
+        ("amazon", "eBook", "$14.99"),
+        ("apple_books", "eBook", "$14.99"),
+    }
+    ebook_only = await svc.catalog_for_book("a1", "b1", format_hint="eBook")
+    assert len(ebook_only) == 2
+    assert all(o.format == "eBook" for o in ebook_only)
 
 
 @pytest.mark.asyncio
@@ -151,6 +211,7 @@ async def test_catalog_for_book_skips_non_verified():
     offers = await svc.catalog_for_book("a1", "b1")
     assert len(offers) == 1
     assert offers[0].price_display == "$14.99"
+    assert offers[0].format == "eBook"
     assert offers[0].price_cents == 1499
 
 
@@ -195,11 +256,27 @@ async def test_catalog_for_book_excludes_google_books():
 async def test_handle_how_much_uses_source():
     svc = PriceCatalogService(MagicMock())
     svc.catalog_for_book = AsyncMock(return_value=[
-        Offer("kobo", "Kobo", "$9.99", 999, "https://k.com", False),
-        Offer("amazon", "Amazon", "$14.99", 1499, "https://a.com", True),
+        Offer("kobo", "Kobo", "$9.99", 999, "https://k.com", False, "eBook"),
+        Offer("amazon", "Amazon", "$14.99", 1499, "https://a.com", True, "eBook"),
     ])
     result = await svc.handle("how much does it cost", "a1", "b1", "Lethal Lines")
     assert "$14.99" in result["text"]
     assert "Amazon" in result["text"]
+    assert "eBook" in result["text"]
     assert result["links"][0]["url"] == "https://a.com"
     assert result.get("platform_offers") is None
+
+
+@pytest.mark.asyncio
+async def test_handle_format_clarify():
+    svc = PriceCatalogService(MagicMock())
+    svc.catalog_for_book = AsyncMock(return_value=[
+        Offer("amazon", "Amazon", "$35.00", 3500, "https://a.com", True, "Hardcover"),
+        Offer("amazon", "Amazon", "$14.99", 1499, "https://a.com", True, "eBook"),
+    ])
+    result = await svc.handle(
+        "are those hardcover or audiobook", "a1", "b1", "All We Say",
+    )
+    assert result["platform_offers"] is not None
+    assert any(o["format"] == "Hardcover" for o in result["platform_offers"])
+    assert "invent" in result["text"].lower() or "format" in result["text"].lower()