Auto-rescan format prices in background when verified listings have none

app/admin/routers/books.py

@@ -48,9 +48,12 @@ async def get_book_platform_presence(
     book_id: str,
     current_user=Depends(get_current_author_scoped),
     db: AsyncSession = Depends(get_db),
+    redis=Depends(get_redis),
 ):
     """Return stored platform presence scan for a book."""
-    result = await BookService(db).get_platform_presence(current_user.id, book_id)
+    result = await BookService(db).get_platform_presence(
+        current_user.id, book_id, redis=redis,
+    )
     if result is None:
         raise HTTPException(404, "Book not found")
     return result

app/services/book_service.py

@@ -181,8 +181,14 @@ class BookService:
             ],
         }
 
-    async def get_platform_presence(self, author_id: str, book_id: str) -> dict | None:
-        """Return stored platform presence scan. None if book not found."""
+    async def get_platform_presence(
+        self, author_id: str, book_id: str, *, redis=None,
+    ) -> dict | None:
+        """Return stored platform presence scan for a book.
+
+        If all verified listings have empty format_prices, schedule a background
+        rescan so format data gets populated without blocking the response.
+        """
         from app.services.platform_catalog import platform_catalog_snapshot
 
         book = await self._books.get_by_id(book_id)
@@ -197,12 +203,49 @@ class BookService:
                 "book": self._book_meta(book),
             }
 
+        verified = [
+            r for r in listings
+            if getattr(r, "status", None) == "verified"
+        ]
+        needs_format_scan = verified and all(
+            not (getattr(r, "format_prices", None) or {})
+            for r in verified
+        )
+        if needs_format_scan and redis is not None and book.title:
+            import asyncio
+            asyncio.create_task(self._background_format_rescan(
+                author_id, book_id, book, redis,
+            ))
+
         return {
             "platform_presence": presence_dict_from_db_listings(listings, source_isbn=book.isbn),
             "listings": platform_catalog_snapshot(listings),
             "book": self._book_meta(book),
         }
 
+    async def _background_format_rescan(
+        self, author_id: str, book_id: str, book, redis,
+    ) -> None:
+        """Run a fresh platform presence scan to populate format_prices."""
+        try:
+            scan = await scan_platform_presence(
+                title=book.title,
+                author=getattr(book, "book_author", None) or "",
+                isbn=getattr(book, "isbn", None) or None,
+                source_platform=getattr(book, "source_platform", None) or None,
+                source_url=getattr(book, "source_url", None) or None,
+                buy_url=getattr(book, "source_url", None) or None,
+                db=self._db,
+                redis=redis,
+            )
+            if scan is not None:
+                await self._listings.replace_from_scan(author_id, book_id, scan)
+                await self._db.commit()
+                if book.source_url:
+                    await save_scan_to_redis(redis, book.source_url, scan)
+        except Exception:
+            logger.warning("background_format_rescan_failed", book_id=book_id)
+
     async def upsert_platform_listing(
         self,
         author_id: str,