diff --git a/.github/ci_checks.py b/.github/ci_checks.py
index 5858a7b..2779f3c 100644
--- a/.github/ci_checks.py
+++ b/.github/ci_checks.py
@@ -81,8 +81,7 @@
 HEX32 = re.compile(r"\b[0-9a-f]{32}\b")
 # Contexts in which a 32-hex string is plainly not a key.
 #
-# Deliberately WITHOUT this site's asset hosts, unlike a sibling repo that
-# needed them: Catawiki serves its images under dashed UUIDs
+# Deliberately WITHOUT this site's asset hosts: Catawiki serves its images under dashed UUIDs
 # (`95be01d1-5c40-4126-94fa-...`), which never match a bare 32-hex run, so
 # the committed fixtures carry none and an allowlist entry for them would be
 # dead configuration that reads like enforcement. Verified by running this
diff --git a/.github/workflows/canary.yml b/.github/workflows/canary.yml
index f8c4d95..fdba4a9 100644
--- a/.github/workflows/canary.yml
+++ b/.github/workflows/canary.yml
@@ -21,10 +21,9 @@ name: canary
 #   Scraping Browser API, country-nl              200, 637 KB, 24 lots
 #
 # Read it by column: the exit address changes nothing and the headless flag
-# changes everything. So a proxy secret would NOT be enough here -- which is
-# the opposite of the sibling repos, where the address is exactly what gets
-# scored -- and there are only two ways for a runner to get in: the Scraping
-# Browser API, or a real window under xvfb.
+# changes everything. So a proxy secret would NOT be enough here, and there
+# are only two ways for a runner to get in: the Scraping Browser API, or a
+# real window under xvfb.
 #
 # THE XVFB ROUTE IS THE CANARY. It was left unverified when this file was
 # first written, and the canary was made dispatch-only around a credential
@@ -45,8 +44,8 @@ name: canary
 #   * The Scraping Browser route is kept, but only on request: dispatch with
 #     `route: cdp` and a CATAWIKI_CDP_ENDPOINT secret set. It is NOT the
 #     scheduled route, because an endpoint on this account does not survive a
-#     day (every credential inherited from the sibling repos was already
-#     returning 401 `deny_no_user`), and a daily run against it would be
+#     day (every credential that was available was already returning 401
+#     `deny_no_user`), and a daily run against it would be
 #     either red every day or green having tested nothing.
 #
 #     gh workflow run canary.yml -R 2scraper/catawiki-scraper -f route=cdp
@@ -98,12 +97,9 @@ jobs:
         # A CATEGORY url, not a search — and on this site that is forced
         # rather than preferred.
         #
-        # A search listing has NO per-page addresses. It is one infinitely
-        # scrolling page, and `?page=2` on a search URL does not advance it,
-        # it EMPTIES the result set ("Oops, produk nggak ditemukan"). So a
-        # search canary could never exercise pagination, which is the thing
-        # this workflow most needs to watch. A category listing paginates
-        # with ?page=N, verified against a real page 2.
+        # Both listing kinds paginate with ?page=N, but a category listing is the
+        # stable one to watch: its lot count does not depend on a query, and
+        # its page 2 was verified against the real site.
         #
         # --pages 3, not 1: with one page pagination is never exercised, so a
         # broken ?page= convention would stay invisible here — precisely the
@@ -159,8 +155,8 @@ jobs:
         # things that are nobody's bug. On the cdp route:
         #
         #   * the SECRET EXPIRED. A Scraping Browser credential is not
-        #     forever — every one inherited from the sibling repos was
-        #     already dead when this repo was written. When it stops
+        #     forever — every one available when this repo was written
+        #     was already dead. When it stops
         #     authenticating the run exits 5.
         #   * ACCESS IS INTERMITTENT PER PROFILE, and a profile allows one
         #     live connection. A canary that collides with a person's run
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6a41f51..8adaef0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,44 @@ or an empty column.
 
 ### Fixed
 
+- **`--retries 0` skipped navigation and reported a block.** The load loop
+  is `range(1, retries + 1)`, so 0 ran it never, `goto` was not called, and
+  the engine judged `about:blank`: a 39-byte empty DOM, exit 3, for a site that
+  was never asked. Reproduced 2026-10-09 (Playwright, `--retries 0`: exit 3 in
+  ~50 ms in both modes; the same command with `--retries 1` fetched 72 lots,
+  `complete`, exit 0). `--retries` now takes an integer of at least 1 in all
+  three engines and refuses 0 as a usage error (exit 2).
+- **The not-served message contradicted the README.** It said a headless
+  browser was the cause, then recommended a residential exit, and said it for a
+  headful run too. One shared `page_flow.not_served_message` now states what
+  was observed (bytes, whether the site's own assets appear) and only then the
+  likely cause: a document under 100 bytes with no site assets is called an
+  empty document and a navigation that did not complete; headless is blamed
+  only when the run was headless.
+- **`--help` and usage errors described a different site** (its modes, URL
+  kinds, currency and page structure). They now describe the real URL kinds
+  and the `listing|lot|auctions` modes, from one set of strings in `page_flow`.
+  The `--mode lot` usage errors no longer point at a mode that does not exist, and the
+  discovery-hub warning, which could never fire, is removed. A suite check walks
+  every string in the three engines for the old wording.
+
+- **`diff_runs.py` refused every `--mode lot` run.** The list of diffable modes
+  named a mode this repo does not have (`product`) instead of `lot`, so a lot
+  run's sidecar was rejected. `listing` and `lot` are diffable; `auctions` rows
+  are a different class and still are not.
+
+### Changed
+
+- The listing sidecar's `extra` no longer carries `scroll` and
+  `pages_still_growing`. No engine ever filled them (this site has no scroll
+  loop), so they were always empty; `result_header` is unchanged. The
+  `--mode lot` branch that read never-set seller facts is removed too.
+- Comments, docstrings and `CONTRIBUTING.md` no longer describe another
+  site's markup, ids, measurements or modes; they describe this site's
+  payload and card, and the real URL kinds. No column or flag changed.
+- `SECURITY.md` no longer says a raw HTML dump contains session cookies; it
+  holds the page markup, not the cookie jar.
+
 - **The Scraper API path (`scraper_api_client.py`) failed whenever a wait flag
   was given, and never saw the target's status.** Measured 2026-09-23 against
   the live `/tasks/sync` endpoint: `waitFor` sent as a JSON-encoded string
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5e7c374..d941319 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -40,40 +40,26 @@ not the check caught it.
 
 ## Reporting a site change
 
-Catawiki changing its markup is the normal way this stops working, and it
-has its own issue template. The detail that saves the most time is WHICH
-anchor broke, because on this site there is no structured data on a listing
-page to fall back on — measured zero `application/ld+json`, zero
-`__NEXT_DATA__` and zero Apollo state across six captures — so the DOM is
-not the primary path by preference, it is the only one.
-
-1. **The grid container.** `[data-testid="divSRPContentProducts"]` on a
-   search page, `[data-ssr="productsCategoryL2/L3SSR"]` on a category
-   listing. If one of these moves the run reports 0 rows and exit 4, which
-   is loud.
-2. **The tile marker.** `[data-testid="imgLeg-c"]` on a search page (one per
-   tile), `[data-testid="divProductWrapper"]` inside
-   `a[data-testid="lnkProductContainer"]` on a category listing.
-3. **The reading ORDER inside the tile** — badge, title, price, was-price,
-   rating, sold, shop, location. The field reads rest on it, deliberately,
-   because the classes around each field are build hashes:
-   `<span class="+tnoqZhn89+NHUA43BpiJg==">` is the title today. If Catawiki
-   reorders a tile, `title` and the prices are what break.
-4. **`span.flip`**, the shop name and the shop's city in that order, exactly
-   two per search tile.
-
-The one place structured data does exist is a DETAIL page's
-`window.__cache` Apollo blob, which is where `--mode product` reads the real
-product id, the exact sold count and the review count.
-
-A third thing can break without any path failing: the **join** between the
-tiles and the structured data. When it breaks, the row count and the prices
-stay healthy while `in_stock` and part of `brand` quietly empty out — so
-every run logs its structured-price confirmation share per page and warns
-below a floor set PER PAGE KIND (search 8%, category 70%, shop 80%; the
-achievable share differs by a factor of eight between them). If you are
-reporting a change, that percentage and the page kind are the numbers to
-include.
+Catawiki changing something is the normal way this stops working, and it has
+its own issue template. The detail that saves the most time is WHICH source
+broke, because the parser reads two different ones for two halves of a row:
+
+1. **The rows** come from the site's own SSR payload,
+   `<script id="__NEXT_DATA__">`, which is in the first response and needs no
+   JavaScript: titles, ids, urls, images, auction ids and the reserve flag. If
+   that moves, the run reports 0 rows and exit 4, which is loud. A lot page
+   (`--mode lot`) is read from the same payload and never from its DOM.
+2. **The money** comes from the rendered card (`.c-lot-card__price` and its
+   siblings), because the payload does not carry it: bids arrive at
+   hydration. If that moves, rows come out with no prices.
+
+`price_source` on a row says which happened: `next_data+dom` is healthy and
+`next_data` means nothing hydrated. A third thing can break without any path
+failing: a status label the page's own translation store no longer maps, which
+leaves `bid_kind` null on rows that have a price. Every run logs its price
+coverage per page and warns below a floor set per page kind (`PRICE_FLOOR` in
+the engines); if you are reporting a change, that percentage and the page kind
+are the numbers to include.
 
 `--dump-html PATH` writes the exact bytes the parser was given, on success as
 well as failure, and a run that finds nothing writes a dump and a screenshot
@@ -191,10 +177,8 @@ silently regress:
   stripping, so the guard would be code that looks load-bearing and never
   runs. Broaden the set and add the guard together.
 - **A sku already written by an earlier page of the same run is dropped, not
-  duplicated.** Unlike its sibling repos this DOES fire on healthy runs
-  here: page 1 and page 2 of one category listing shared exactly 3 products,
-  all three from the "cheaper products" carousel that appears on every page.
-  So a small non-zero drop count is expected and a large one is not. See
+  duplicated.** A live auction listing reorders as lots close, so a small
+  non-zero drop count is possible and a large one is not. See
   `dedupe_by_key` in `output_writer.py`.
 
 There is also a naming check: certain phrases are banned repo-wide and the suite
diff --git a/README.md b/README.md
index abf930b..1c990c7 100644
--- a/README.md
+++ b/README.md
@@ -37,8 +37,7 @@ Anything not measured is not claimed.
 Read it by column, not by row: the exit address changes nothing and the
 headless flag changes everything. So:
 
-* **`--headful` is the default here**, unlike every sibling repo in this
-  family. A `--headless` default would be a scraper whose default cannot
+* **`--headful` is the default here.** A `--headless` default would be a scraper whose default cannot
   fetch the site.
 * `--headless` is still accepted, because `--cdp-endpoint` ignores it and
   because a change on the site would make it work again. It will report
diff --git a/SECURITY.md b/SECURITY.md
index 914fd48..9258531 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -100,7 +100,10 @@ Three places leak credentials that people do not expect, because unlike our own
 log lines they are **not** masked:
 
 - **raw HTML dumps** (`--dump-html`, and the automatic dump on a zero-product
-  run) — these can contain session cookies
+  run) — the page's markup as the browser serialised it, not the cookie jar,
+  but a site can write session identifiers or CSRF tokens into inline scripts,
+  so treat a dump as sensitive. A blocked page's dump is a few hundred bytes
+  and carries none
 - **the Scraper API's `x-debug` response header**
 - **your shell history**, if you passed a key on the command line
 
diff --git a/captcha_solver.py b/captcha_solver.py
index 2e8535a..8a5792c 100644
--- a/captcha_solver.py
+++ b/captcha_solver.py
@@ -703,10 +703,8 @@ class CaptchaUnsolvable(RuntimeError):
 # ===========================================================================
 # What is deliberately NOT here
 # ===========================================================================
-# The sibling repo in this family carries a whole second solver for its
-# site's OWN first-party image captcha ("Enter the characters you see below",
-# a JPEG of distorted text and a GET form). Roughly 190 lines of it, and none
-# of it is ported here, because this site has no such page.
+# A solver for a site's OWN first-party image captcha (a JPEG of distorted
+# text and a form) is not here, because this site has no such page.
 #
 # What this site does instead is refuse a HEADLESS browser. Measured
 # 2026-09-10 from five different addresses, four of them residential: Akamai
diff --git a/diff_runs.py b/diff_runs.py
index 26d09bd..39251a8 100644
--- a/diff_runs.py
+++ b/diff_runs.py
@@ -93,12 +93,9 @@ def _within_tolerance(before: dict, after: dict, changes: dict,
                       tolerance_pct: float) -> bool:
     """True if every differing price field moved by less than `tolerance_pct`.
 
-    Inherited from this family rather than earned here, and said plainly
-    because the alternative is a comment inventing a reason. A sibling repo
-    needs it: that site converts prices for a cross-border visitor and the
-    exchange rate ticks between two runs of the same command. NO EQUIVALENT
-    CATAWIKI BEHAVIOUR WAS MEASURED — this site quotes euro to every
-    visitor, on all 18 locales including Japanese and Chinese and from every
+    Part of the family's diff contract, and said plainly because the
+    alternative is a comment inventing a reason. NO CATAWIKI BEHAVIOUR NEEDS
+    IT — this site quotes euro to every visitor, on all 18 locales including Japanese and Chinese and from every
     exit tried, so a run holds no conversion and every cent of a difference
     is a real move.
 
@@ -318,9 +315,9 @@ def _check_comparable(args) -> bool:
     # A CURRENCY MISMATCH, which on this site should be impossible — and is
     # checked anyway.
     #
-    # The sibling repos guard cross-storefront diffs with `source`: eleven
-    # country hostnames, so a run of one against another is refused on the
-    # hostname alone. Catawiki is ONE host with ONE currency — 18 locales as
+    # Cross-storefront diffs are normally guarded with `source`, so a run of one
+    # hostname against another is refused on the hostname alone. Catawiki is
+    # ONE host with ONE currency — 18 locales as
     # a path prefix, euro on every one of them, measured 2026-09-10 — so
     # `source` is "catawiki.com" on both sides and there is no storefront
     # split for it to catch.
@@ -382,9 +379,9 @@ def parse_args():
                         "rate tick rather than a price change: reported "
                         "separately and ignored by --fail-on-change. Default 0 "
                         "(report every cent), which is what a Catawiki "
-                        "run wants: the site quotes IDR to every visitor, so "
+                        "run wants: the site quotes euro to every visitor, so "
                         "there is no conversion drift to absorb. The flag is "
-                        "inherited from this scraper family; set it non-zero "
+                        "part of the family's diff contract; set it non-zero "
                         "only with a reason you can state.")
     p.add_argument("--fail-on-change", action="store_true",
                    help="Exit 1 if anything was added, removed or changed — "
diff --git a/env_config.py b/env_config.py
index 1fce048..159964a 100644
--- a/env_config.py
+++ b/env_config.py
@@ -200,7 +200,7 @@ def _dests_given_on_argv(dests, argv=None):
     remote browser the caller had just asked it not to use. There was no
     spelling of "ignore what the file says" at all.
 
-    That matters more here than in the sibling repos: this site's local
+    That matters here because this site's local
     headful path and its Scraping Browser path are both first-class, and
     switching between them is routine rather than exceptional.
 
diff --git a/output_writer.py b/output_writer.py
index 52aac73..0818294 100644
--- a/output_writer.py
+++ b/output_writer.py
@@ -3,24 +3,18 @@
 -----------------
 Shared row models + JSON/CSV writers used by all three scrapers.
 
-Two modes, one row shape
-------------------------
-    --mode listing   a search grid or a category listing -> Product
-    --mode product   one /{shop}/{slug} detail page -> Product, with the
-                     trailing detail-only fields populated
-
-The listing and lot modes yield the SAME class, because here a lot page is not a
-different kind of object from a tile — it is the same product described more
-fully. So there is no second dataclass here (a sibling repo needs one for
-reviews; this one does not), and `diff_runs.py` can compare a listing run
-against a product run on the columns both populate.
-
-There is deliberately no `--mode seller`. A seller's own page is its own
-application shell with its own markup, none of which has been captured or
-measured, and a mode that ships untested would be worse than a mode that is
-absent. `product_parser.shop_metadata` reads the seller's facts off a detail
-page for the sidecar, which is what a run covering one product can honestly
-say about its seller.
+Three modes, two row shapes
+---------------------------
+    --mode listing   a category, a search or a whole auction -> Product
+    --mode lot       one /{loc}/l/{id}-{slug} page -> Product, with the
+                     lot-page-only columns populated
+    --mode auctions  the auctions index as a work list -> Auction
+
+A lot page is not a different kind of object from a listing card, it is the
+same lot described more fully, so listing and lot rows are the SAME class and
+`diff_runs.py` can compare a listing run against a lot run on the columns both
+populate. An auction is a different kind of thing, so it gets its own class
+rather than a Product with most columns null.
 
 `Product` keeps the family's first sixteen columns in the family's order,
 with this site's own ones appended after `position`, so a consumer
@@ -37,13 +31,11 @@
 from typing import Optional, List, Set, Sequence, Any, Type
 
 
-# The hostname a row came from. Catawiki is ONE storefront — 18 locales as a
-# path prefix on one host — measured by
-# fetching the same URL from an Indonesian and a US exit and getting
-# identical markup, identical `<html lang="id">` and identical IDR prices —
-# so this column is `catawiki.com` on every row of every run. It is kept
-# because the family's schema has it in this position and consumers read the
-# columns by name across repos.
+# The hostname a row came from. Catawiki is ONE storefront: the locale is a
+# path segment on one host and prices are euro on every locale, so this column
+# is `catawiki.com` on every row of every run. It is kept because the family's
+# schema has it in this position and consumers read the columns by name
+# across repos.
 SOURCE_DEFAULT = "catawiki.com"
 
 
@@ -52,80 +44,42 @@ class Product:
     source: str = SOURCE_DEFAULT
     scraped_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
     url: str = ""
-    # The product's `/{shop-slug}/{product-slug}` path, and NOT the 19-digit
-    # tail most slugs end in.
-    #
-    # That tail is tempting and wrong. The site's own id for this product is
-    # `pdpBasicInfo.productID` in a detail page's Apollo cache —
-    # 103490518624 where the URL tail is 1731177319241910164 — and 4 of 40
-    # listing URLs carry no tail at all (two carry a short hex suffix
-    # instead), all four ordinary organic products with identical markup. So
-    # a tail-derived sku would have been a different number than the site's,
-    # null on a tenth of every run, and nobody would have noticed either.
-    #
-    # The path is always present, is what the site's own canonical uses, and
-    # is what a listing row and a detail row join on. `product_id` below
-    # carries the real numeric id where a page states it.
+    # The lot id: the number after `/l/` in the lot's URL, which is also the
+    # id the page's own payload carries.
     sku: Optional[str] = None
     title: Optional[str] = None
-    # The SHOP. On a marketplace of small sellers the shop IS the brand, and
-    # A listing publishes no manufacturer field anywhere, so this column
-    # carries the seller's display name instead of being null on every row.
-    # Read from the tile on a search page (95/95), from the badge image's alt
-    # on a category tile, and from `pdpBasicInfo.shopName` on a detail page;
-    # falls back to the slug in the URL, which names the same seller.
+    # A listing publishes no brand field, and splitting the title on its
+    # dashes would be a guess presented as a fact, so this is null on a
+    # listing row. A lot page's own specifications carry a real Brand, which
+    # fills it in --mode lot.
     brand: Optional[str] = None
+    # `bid_kind` below says WHICH quantity this is.
     price: Optional[float] = None
-    # IDR, and on this site that is a fact rather than a guess: one
-    # storefront, one currency, and the two exit countries tested returned
-    # zero price differences across the 68 products both saw. Still null
-    # rather than defaulted when no price was found — a row with no price has
-    # no currency either.
+    # Euro on every locale. Null rather than defaulted when no price was
+    # found: a row with no price has no currency either.
     currency: Optional[str] = None
-    # The was-price, from the tile's strike node. 88 of 95 search tiles carry
-    # one; a CATEGORY tile carries none at all (0 of 60), which is a property
-    # of that page kind and not a parsing failure. Null in --mode product: a
-    # detail page has no strikethrough of its own and the "similar products"
-    # carousel's strikes belong to other products.
+    # Family columns that this site's parser never sets, so they are null on
+    # every row: Catawiki has no was-price, no per-lot rating and no review
+    # count. They stay for now so the family's column prefix is unchanged.
     original_price: Optional[float] = None
-    # Computed from the two prices, never read off the printed badge.
-    # A sibling site only prints its badge above some threshold — two tiles carry
-    # a strike at 7% and 8% off with no badge — so computing recovers 88 rows
-    # where reading recovers 86, and where both exist they agreed on all 86.
     discount_pct: Optional[float] = None
-    # A per-item rating, which this site does not publish at all — worth
-    # stating because a sibling repo's tile stars are the SHOP's, and folding
-    # the two together would make one column mean different things per site.
-    # 95/95 on a search page, 0/60 on a category page (that tile kind prints
-    # none at all), and `pdpBasicInfo.stats.rating` on a detail page.
     rating: Optional[float] = None
-    # Null on every listing row and populated in --mode product, from
-    # `stats.countReview`. A tile prints the sold count, never the review
-    # count.
     review_count: Optional[int] = None
-    # Only a detail page says: `status == "ACTIVE"` with a non-zero
-    # `maxOrder`. A tile does not state availability at all, so this is null
-    # on a listing run rather than assumed true.
+    # Set on a lot page only, as "the lot is not closed" when a price or a
+    # closed state is known. A listing card does not state it, so it is null
+    # on a listing run rather than assumed.
     in_stock: Optional[bool] = None
-    # Sparse ON PURPOSE, and this is the trap on this site.
-    #
-    # A sibling site lazy-loads its tile images, so a tile below the fold carries a
-    # PLACEHOLDER in `src`: 55 of 95 search tiles held an SVG under
-    # `/zeus_v2/` and 30 of 60 category tiles held a `data:` URI. Reading
-    # `src` blindly gives a column that is 100% populated and half wrong, so
-    # a real image is recognised positively by its host and everything else
-    # is null. Scroll further and more rows fill in.
+    # From the listing payload's own image fields (originalImageUrl, else
+    # thumbImageUrl) and the lot page's image list. Null when the site
+    # published no image url for that lot.
     image_url: Optional[str] = None
     category: Optional[str] = None
     # Where `price` came from:
-    #   "dom"          the rendered tile. The ONLY case on a listing page —
-    #                  there is no structured data on one to confirm against,
-    #                  which is measured rather than assumed (0 JSON-LD, 0
-    #                  __NEXT_DATA__, 0 Apollo state on six captures).
-    #   "meta+apollo"  --mode product: the price from the page's own
-    #                  `product:price:amount` meta, everything else from its
-    #                  Apollo cache.
-    #   "meta"         --mode product where the Apollo cache was absent.
+    #   "next_data+dom"  a listing row: the amount read off the hydrated
+    #                    card, everything else from the page's payload.
+    #   "next_data"      the payload alone: a lot page, or a listing row
+    #                    whose card had not hydrated (so it has no price).
+    #   "dom"            the fallback path, read off the card with no payload.
     # diff_runs.py reports a price change that comes with a price_source
     # change as `source_changed`, not `changed`: that says something about
     # our own two snapshots, not about the site.
@@ -134,13 +88,9 @@ class Product:
     # ---- site-specific, appended so the family prefix stays stable ----
     # Which listing page this row came from (1-based) and its position in
     # that page as the site ordered it. Without `page`, `position` is
-    # ambiguous — it restarts at 1 on every page. Both null in --mode
-    # product, where there is no page.
+    # ambiguous — it restarts at 1 on every page.
     page: Optional[int] = None
     position: Optional[int] = None
-    # The seller's URL slug, from the row's own path. Always present, and
-    # kept beside `brand` because a shop's display name can change and its
-    # slug is what the URL commits to.
     # ---- Catawiki-specific, appended after the family prefix (§9) ----
     # WHICH quantity `price` is. Three states share one node on a listing
     # card and are told apart only by a label in the page's language, which
@@ -219,9 +169,6 @@ class Product:
     # implied by the source (§9).
     listing_kind: Optional[str] = None
 
-# Row classes by --mode, so an engine maps its mode to a schema in one place.
-# Both modes are Product here; the mapping exists so adding a mode later is a
-# one-line change rather than a search for every place that assumed Product.
 @dataclass
 class Auction:
     """One row per AUCTION, for --mode auctions.
@@ -253,12 +200,13 @@ class Auction:
     position: Optional[int] = None
 
 
+# Row classes by --mode, so an engine maps its mode to a schema in one place.
 ROW_CLASS_BY_MODE = {"listing": Product, "lot": Product, "auctions": Auction}
 
 # Modes whose rows are one-per-sku, and therefore safe to dedupe on `sku` and
-# to hand to diff_runs.py. Both of this repo's modes qualify: a listing page
-# names each product once, and a product page IS one product.
-UNIQUE_BY_SKU_MODES = ("listing", "product")
+# to hand to diff_runs.py. A listing names each lot once and a lot page IS one
+# lot. `auctions` rows are a different class and are refused by the diff.
+UNIQUE_BY_SKU_MODES = ("listing", "lot")
 
 
 def dedupe_by_key(rows: Sequence[Any], seen: Set[str], key: str = "sku") -> List[Any]:
@@ -266,19 +214,17 @@ def dedupe_by_key(rows: Sequence[Any], seen: Set[str], key: str = "sku") -> List
 
     `seen` is mutated in place, so callers thread the same set across pages —
     a stale or repeating next-page link then re-parses a page without
-    duplicating its rows into the final output. On this site this DOES fire
-    on healthy runs: page 1 and page 2 of one category listing shared
-    exactly 3 products, all three from the "cheaper products" carousel that
-    appears on every page of a listing. So a small non-zero drop count here
-    is expected and a large one is not.
+    duplicating its rows into the final output. A small non-zero drop count
+    is expected on a healthy run, since a listing page can repeat a lot a
+    neighbouring page already carried; a large one is not.
 
     A row with no key is always kept: there is nothing to check a duplicate
     against, and dropping it would be a silent data loss rather than a
     duplicate removal.
 
-    Both of this repo's modes are one row per `sku`, so `key` is never
-    overridden here — the parameter exists because the rest of the family
-    shares this function and one of them needs it.
+    The modes that use this are one row per `sku`, so `key` is not overridden
+    here; the parameter exists because the rest of the family shares this
+    function.
     """
     fresh = []
     for r in rows:
@@ -340,19 +286,15 @@ def write_csv(rows: Sequence[Any], path: str, row_cls: Type = Product) -> None:
 # search genuinely matched nothing" from "something stood between us and the
 # content". See product_parser.detect_bot_challenge.
 #
-# On this site this code specifically does NOT cover the three ways to get a
-# real page with no products on it: a `/p/<slug>` discovery hub, which
-# answers 200 with banners and carousels and no grid; a search whose query
-# matches nothing ("Oops, produk nggak ditemukan"); and one page past the
-# end of a category listing. All three are EXIT_NO_PRODUCTS — the request
-# was served exactly as asked and simply has no products on it. Reporting
-# any of them as blocked would send a user hunting for a proxy problem that
-# does not exist.
+# This code does NOT cover the ways to get a real page with no products on
+# it: a search whose query matches nothing, and one page past the end of a
+# listing. Both are EXIT_NO_PRODUCTS: the request was served exactly as asked
+# and simply has no products on it. Reporting either as blocked would send a
+# user hunting for a proxy problem that does not exist.
 #
-# What EXIT_BLOCKED means here is unusually literal: this site refuses a
-# address it has scored NOTHING at all. No status code, no interstitial, no
-# vendor marker — the HTTP/2 stream is reset and the run sees a connection
-# error rather than a page.
+# What EXIT_BLOCKED means here: Akamai answered with HTTP 403 and a short
+# "Access Denied" page that carries nothing to solve, which this site does to
+# a headless browser whatever its address. See the README.
 EXIT_BLOCKED = 3
 
 # Exit code for a run that gathered SOME rows and then stopped early — a
@@ -441,13 +383,8 @@ def run_meta(status: str, stop_reason: str, pages_requested: int,
     here, since the site has one storefront and one currency; it is kept
     because consumers read these columns by name across the family.
 
-    `extra` carries facts about the run that are not about any single row.
-    `--mode shop` uses it for the SELLER's own name, location, rating and
-    review count: a run covers exactly one shop, so those belong to the run
-    rather than repeated down a column, and the shop's review count (16679
-    on the captured seller) is a different number from its listings' own
-    (827 on one of them) — putting them in one column would make the schema
-    lie.
+    `extra` carries facts about the run that are not about any single row,
+    such as a lot page's seller metadata.
 
     `pages_failed` lists the pages that did not yield data, by number.
     `pages_completed` alone was enough only while pages were fetched strictly
@@ -518,15 +455,12 @@ def save(rows: Sequence[Any], out_prefix: str, fmt: str,
 # the DATA (a page contributed nothing not already seen, so the listing is
 # over), while the second is a property of a CSS SELECTOR and is therefore
 # the weaker signal — a renamed attribute looks identical to a short
-# catalogue. On this site that ordering is not a preference, it is the only
-# thing that works: the site publishes NO `link[rel=next]` and no numbered
-# anchors anywhere, a CATEGORY listing is addressable by `?page=N`, and a
-# SEARCH is not addressable at all — `?page=2` there returns an empty result
-# set rather than page 2. So "no new products" is the one termination
-# condition available on a search. See page_flow.pagination_is_addressable.
+# catalogue. The site publishes no `link[rel=next]`; both listing kinds are
+# addressable by `?page=N` (see page_flow.pagination_is_addressable), and "no
+# new products" is the termination condition that does not depend on markup.
 #
-# "single_page_mode" is complete by construction: --mode product reads one
-# page because one page is all there is.
+# "single_page_mode" is complete by construction: --mode lot and --mode
+# auctions read one page because one page is all there is.
 COMPLETE_STOP_REASONS = ("completed", "pagination_exhausted", "no_new_products",
                          "single_page_mode")
 
@@ -557,9 +491,8 @@ def finish_run(rows: Sequence[Any], out_prefix: str, fmt: str,
     # sidecar — a file that contradicts itself, and a pipeline branching
     # on `status` reading a short run as a whole one.
     #
-    # Found by a third-party audit of a sibling repo and measured across
-    # the family by CALLING each `finish_run` rather than grepping for the
-    # fix: 28 of 32 repos behaved this way. Same shape as the exit-code
+    # Found by a third-party audit and measured by CALLING `finish_run`
+    # rather than grepping for the fix. Same shape as the exit-code
     # unification this file already carries — a rule keyed on a list of
     # names has a hole for every name nobody added to it.
     complete = stop_reason in COMPLETE_STOP_REASONS and not pages_failed
diff --git a/page_flow.py b/page_flow.py
index 88fe4df..822fa97 100644
--- a/page_flow.py
+++ b/page_flow.py
@@ -34,13 +34,12 @@
 did not change the page height on any of the three page kinds (24 -> 24 on a
 category listing, 24 -> 24 on a search grid, 40 -> 40 on a lot page). Every
 listing page holds its whole 24 lots and paginates by URL, so a scroll here
-would be latency bought for nothing. The opposite of a sibling repo, where
-the scroll is the only way any product is ever seen -- which is exactly why
-this was checked instead of ported.
+would be latency bought for nothing.
 """
 
 from __future__ import annotations
 
+import argparse
 import logging
 from typing import Callable, Dict, Iterable, List, Optional, Union
 from urllib.parse import urljoin, urlsplit
@@ -54,6 +53,11 @@
 
 logger = logging.getLogger("page_flow")
 
+# Below this a document with no reference to the site's assets is an empty
+# DOM (a bare <html><head></head><body></body></html> is 39 bytes), not the
+# refusal page, which is 300+ bytes.
+EMPTY_DOM_BYTES = 100
+
 
 # ---------------------------------------------------------------------------
 # Readiness
@@ -152,8 +156,8 @@ def wait_for_count(count: Callable[[str], int], sleep: Callable[[int], None],
 
     Polls a COUNT rather than waiting on an evaluated string. Playwright's
     `wait_for_function` hands the browser a string to evaluate, which a site
-    whose CSP lacks `unsafe-eval` refuses outright -- it took a sibling repo's
-    run down with `EvalError` and exit 1 on the site's most obvious URL.
+    whose CSP lacks `unsafe-eval` refuses outright -- the run
+    dies with `EvalError` and exit 1.
     Catawiki's CSP does allow `unsafe-eval` today (checked on all three page
     kinds: `script-src 'self' 'unsafe-eval' ...`), so this is not a bug being
     worked around here -- it is one not being invited back in when a header
@@ -182,10 +186,9 @@ def classify(html: Optional[str], status: Optional[int] = None,
     """Which of the five states this response is.
 
     `status` is positional and comes SECOND, matching `detect_page_state`.
-    Getting that wrong is not a style question: a sibling repo shipped two of
-    three engines calling this as `classify(html, url=...)`, both crashed on
-    their first fetch, and nothing short of a live run or a signature-binding
-    check saw it (§17).
+    Getting that wrong is not a style question: an engine calling this as
+    `classify(html, url=...)` crashes on its first fetch, and nothing short of
+    a live run or a signature-binding check sees it (§17).
     """
     if html is None:
         # A bare navigation failure. On this site that IS what a refusal
@@ -204,8 +207,7 @@ def classify(html: Optional[str], status: Optional[int] = None,
 #   blocked  does this count towards exit 3?
 STATE_POLICY: Dict[str, Dict[str, bool]] = {
     "content":   {"parse": True,  "retry": False, "solve": False, "blocked": False},
-    # NOT parsed, and this is the one policy row that differs from every
-    # sibling repo. A Catawiki search that matches nothing answers HTTP 200,
+    # NOT parsed, and this row is deliberate. A Catawiki search that matches nothing answers HTTP 200,
     # prints "No results", and BACKFILLS the grid with 24 suggested lots that
     # its payload reports as `total: 24`. Parsing an `empty` page here would
     # write two dozen plausible, well-formed rows for a query that matched
@@ -256,7 +258,7 @@ def is_unpainted(state: str, html: Optional[str]) -> bool:
 # client, not the address.
 #
 # So the retry budget for a block is spent on a change that cannot help. It
-# is deliberately 0 here, against `True` in the siblings, and the engines
+# is deliberately 0 here, and the engines
 # read this constant rather than computing their own budget -- a policy
 # constant nothing consults is the same defect as dead code (§17).
 RETRY_ON_BLOCKED = False
@@ -292,6 +294,95 @@ def block_advice(html: Optional[str], headless: bool,
             f"the path measured to work.")
 
 
+def not_served_message(html: Optional[str], headless: bool, has_pool: bool,
+                      tries: int, debug_html: str) -> str:
+    """The log line for a page the site did not serve (exit 3).
+
+    One text for all three engines, built from the same facts as
+    `block_advice`. It states what was OBSERVED -- the byte count and whether
+    the document references the site's own assets -- and only then what that
+    usually means here. A document of a few dozen bytes is an EMPTY DOM, not
+    Akamai's refusal (a 394-byte "Access Denied"), and no HTTP status
+    reaches this line, so it must not claim the site refused anything.
+    """
+    n = len(html or "")
+    served = served_by_catawiki(html or "")
+    seen = (f"The site did not serve this request: {n} bytes, "
+            f"{'which references' if served else 'with no reference to'} "
+            f"the site's own asset host, saved to {debug_html}.")
+    if n < EMPTY_DOM_BYTES and not served:
+        what = (f" That is an empty document, not a refusal page (Akamai's "
+                f"is a 394-byte \"Access Denied\"), so the navigation most "
+                f"likely never completed: check the network and that "
+                f"--retries is at least 1.")
+        if headless:
+            what += (" This run was HEADLESS, which this site refuses "
+                     "whatever the address; --headful is the default.")
+    elif headless:
+        what = (" This run was HEADLESS, and Akamai refuses a headless "
+                "browser here regardless of the exit address. Run "
+                "--headful, or use --cdp-endpoint.")
+    else:
+        what = (" This run was headful, so the cause is not the headless "
+                "flag; the exit address may be scored. "
+                + ("Rotation is unlikely to help here; " if has_pool else "")
+                + "--cdp-endpoint is the path measured to work.")
+    return (f"{seen}{what} Tried {tries} time(s). This is exit 3, distinct "
+            f"from a genuinely empty result (exit 4).")
+
+
+def attempts(value: str) -> int:
+    """argparse type for --retries: attempts per page load, so at least 1.
+
+    The loop is `range(1, retries + 1)`. Zero ran it NEVER, `goto` was not
+    called, and the engine judged about:blank -- an empty DOM reported as
+    "blocked" (exit 3) for a site that was never asked.
+    """
+    try:
+        n = int(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"{value!r} is not an integer")
+    if n < 1:
+        raise argparse.ArgumentTypeError(
+            "must be at least 1: it counts attempts per page load, and 0 "
+            "would attempt none and judge a page that was never fetched")
+    return n
+
+
+def mode_url_mismatch(mode: str, url: str, kind: str) -> Optional[str]:
+    """The usage error for a --mode that cannot read this URL, or None."""
+    if mode == "lot" and kind != "lot":
+        return (f"--mode lot expects a /{{loc}}/l/{{id}}-{{slug}} lot URL; "
+                f"{url!r} is a {kind or 'unrecognised'} page.")
+    if mode == "listing" and kind == "lot":
+        return (f"{url!r} is a single lot page. Use --mode lot for it, or "
+                f"pass a category (/{{loc}}/c/{{id}}-{{slug}}), a search "
+                f"(/{{loc}}/s?q=...) or an auction (/{{loc}}/a/{{id}}-{{slug}}) "
+                f"URL.")
+    return None
+
+
+URL_HELP = ("A Catawiki URL: a category /{loc}/c/{id}-{slug}, a search "
+            "/{loc}/s?q=..., an auction /{loc}/a/{id}-{slug}, the auctions "
+            "index /{loc}/a (--mode auctions), or one lot "
+            "/{loc}/l/{id}-{slug} (--mode lot). Required, unless "
+            "CATAWIKI_URL is set in the environment or in .env.")
+MODE_HELP = ("listing (default): a category, a search or a whole auction, "
+             "24 lots per page on the first two. lot: one lot page, adding "
+             "the estimate, the seller and their feedback score, the "
+             "specifications and the bid history. auctions: the auctions "
+             "index as a work list, one row per auction, to feed back in "
+             "as --url.")
+PAGES_HELP = ("Listing pages to crawl (--mode listing on a category or a "
+              "search; ?page=N, capped by the site at 100). Ignored in "
+              "--mode lot and --mode auctions, and for a whole auction, "
+              "which is one page.")
+RETRIES_HELP = ("Attempts per page load before giving up (default 3, "
+                "minimum 1). The pause between attempts doubles each time. "
+                "A page that comes back EMPTY is not retried: an empty "
+                "listing is a correct answer, not a fault.")
+
+
 # ---------------------------------------------------------------------------
 # Pagination
 # ---------------------------------------------------------------------------
diff --git a/playwright_scraper.py b/playwright_scraper.py
index 0de95dd..b788ca3 100644
--- a/playwright_scraper.py
+++ b/playwright_scraper.py
@@ -25,7 +25,7 @@
   2026-09-10: HTTP 403 and a 394-byte Akamai "Access Denied" from four
   residential exits and one datacentre address, against HTTP 200 and the full
   catalogue from those very same addresses with a real window. So `--headful`
-  is the DEFAULT here, against headless in every sibling repo, and
+  is the DEFAULT here, and
   `page_flow.RETRY_ON_BLOCKED` is False: rotating an exit spends the budget
   on a change that cannot help. `--cdp-endpoint` is the other measured-
   working path.
@@ -45,8 +45,7 @@
 
 * **There is no scroll, and that is measured.** Three scrolls to the
   document's own bottom added zero cards and left the page height unchanged
-  on all three page kinds. A sibling repo cannot see one product without its
-  scroll loop, which is exactly why this was checked here rather than ported.
+  on all three page kinds.
 
 * **Pagination is arithmetic, and the site caps it at 100 pages.** Page 1's
   payload states `total` and `lotsPerPage`, so every page's address is
@@ -149,29 +148,16 @@ class PageOutcome:
     load_failed: bool = False
     # The page_flow state this page came back as ("content", "blocked",
     # "challenge", "empty", "unknown"). Carried so the caller can tell an
-    # EMPTY page — a /p/<slug> hub, a no-match query, or one page past the
+    # EMPTY page — a search that matches nothing, or one page past the
     # end of a listing — from a page that failed. Both produce zero rows and
     # they mean opposite things.
     state: Optional[str] = None
-    # What the listing itself says its catalogue size is. Populated here,
-    # unlike in a sibling repo: the SSR payload states `total` and
+    # What the listing itself says its catalogue size is. Populated: the SSR payload states `total` and
     # `lotsPerPage` on page 1 (11,681 and 24 on the category measured), which
     # is what makes the page count arithmetic rather than a link to follow.
     total_available: Optional[int] = None
-    # The raw result-count header, verbatim, for the sidecar. Worth recording
-    # and worth nothing as a count — after one scroll it claimed 61-180 while
-    # the DOM held 95 tiles.
+    # The query a search page ran, read from its payload, for the sidecar.
     header: Optional[str] = None
-    # What the lazy-load scroll did: rounds spent, cards reached, and whether
-    # it SETTLED. That last flag is the important one — a page whose grid was
-    # still growing when the round budget ran out is partial, and a run that
-    # reported it as complete would read as a shrinking catalogue.
-    scroll: Optional[dict] = None
-    # In --mode product, the seller's own id/name/slug read off the page's
-    # Apollo cache. Stored as the small dict rather than by keeping the
-    # page's HTML around: a detail page is 285 KB and a scrolled listing
-    # nearly 1 MB.
-    shop_facts: Optional[dict] = None
 
     @property
     def ok(self) -> bool:
@@ -207,7 +193,7 @@ def ok(self) -> bool:
 # A page holding less than this share of the fullest page in the same run is
 # reported as thin. This site's page size is steady — 24 lots per category
 # and search page on every capture and every live run — so the bar can sit
-# closer than it does on the sibling repos, but not
+# fairly close, but not
 # tight: the last page of a listing is legitimately short.
 THIN_PAGE_SHARE = 0.6
 
@@ -236,9 +222,7 @@ def _driver(page):
 # No scroll primitives and no `page_height` here, and that is measured
 # rather than omitted: three scrolls to the document's own bottom added zero
 # cards and left the page height unchanged on all three page kinds. Every
-# listing page holds its whole 24 lots and paginates by URL. A sibling repo
-# cannot see a single product without the scroll, which is exactly why this
-# was checked here instead of ported (see page_flow's docstring).
+# listing page holds its whole 24 lots and paginates by URL. (See page_flow's docstring.)
 
 
 def _ready_selector(args) -> str:
@@ -303,13 +287,9 @@ def _plan_page_urls(page, args, page_one_url: str) -> Optional[List[str]]:
     On Catawiki both listing kinds are addressable and the site's own links
     agree with the convention — but the site CAPS it at 100 pages, and a
     request past the cap returns page 100's lots under HTTP 200 rather than
-    failing. A category listing is addressable: `?page=2` on
-    /p/makanan-minuman/minuman/kopi-bubuk returned 61 products against page
-    1's 66, overlapping by 3 (the "cheaper products" carousel that appears
-    on both). A SEARCH is not: `?page=2` on a search URL does not advance
-    it, it EMPTIES the result set — "Oops, produk nggak ditemukan", no grid,
-    no prices. A planner that built `?page=N` regardless would fetch that,
-    find no new sku, and report a COMPLETE run holding page 1.
+    failing. A page past the end can repeat lots an earlier page carried, so
+    the run still ends on "no new sku" rather than trusting the address
+    alone.
     """
     if args.pages < 2:
         return None
@@ -319,8 +299,7 @@ def _plan_page_urls(page, args, page_one_url: str) -> Optional[List[str]]:
     dropped = len([h for h in hrefs if h]) - len(candidates)
     if dropped > 0:
         logger.info("Ignored %d advertised page-2 link(s) that paginate "
-                    "something other than this listing (a shop front's "
-                    "review pages are the known case).", dropped)
+                    "something other than this listing (e.g. a carousel or filter link).", dropped)
 
     constructed = page_url(page_one_url, 2)
     if candidates:
@@ -375,14 +354,13 @@ def _same_url(a: str, b: str) -> bool:
 
     Delegates to page_flow rather than reimplementing the comparison, so all
     three engines cannot drift on it. An engine that carried its own copy of
-    this in a sibling repo went stale and silently fell back to sequential
-    fetching — the exact divergence page_flow.py exists to prevent,
-    reproduced inside one engine.
-
-    On this site the comparison has to strip a long tracking tail: a listing
-    anchor arrives with `?extParam=…keyword=kopi&search_id=…&src=search` and
-    a detail page's own canonical arrives with a UTM triple, so two views of
-    one page never match unless both sides are cleaned.
+    this inside one engine can go stale and silently fall back to sequential
+    fetching — the exact divergence page_flow.py exists to prevent.
+
+    On this site the comparison has to strip a long tracking tail: a link the
+    site generates can carry tracking parameters that a canonical address
+    does not, so two views of one page never match unless both sides are
+    cleaned.
     """
     return page_flow.comparable(a) == page_flow.comparable(b)
 
@@ -863,18 +841,18 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
 
         if not page_flow.should_retry(state):
             # "content" and "empty" are both final answers. An empty page is
-            # a CORRECT one — a hub category has no grid, and one page past
+            # a CORRECT one — an empty listing has no grid, and one page past
             # the end of a listing has no products — so retrying it would
             # spend the user's budget re-confirming the same right answer,
             # and rotating the exit would blame an address for the URL it was
             # given.
             break
 
-        # Blocked or challenged. A different exit is the one thing that
-        # plausibly changes the outcome: the ADDRESS is what was scored, not
-        # the URL, so retrying it unchanged would only confirm it. Measured
-        # 2026-09-09 — the same URL that answers 403 from a datacentre exit
-        # answers 200 from a residential one.
+        # Blocked or challenged. The retry budget is 0 here
+        # (page_flow.BLOCK_RETRIES_*): this site refuses a headless browser
+        # whatever the exit, so a second attempt from another address would
+        # spend the budget on a change that cannot help. The branch stays so
+        # the budget, not the code path, is what a future measurement edits.
         if block_attempt < block_retries:
             if has_pool:
                 logger.warning("Page %d came back as %s from %s — retrying "
@@ -921,24 +899,10 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
         with open(debug_html, "w", encoding="utf-8") as f:
             f.write(html or "")
         served = served_by_catawiki(html or "")
-        logger.error(
-
-            "The site did not serve this request — %d bytes, %s the site's "
-            "own asset host, saved to %s. On this site a refusal is a 394-byte "
-            "\"Access Denied\" with no vendor name and nothing to solve, and "
-            "it is triggered by the browser being headless rather than by the "
-            "address: no interstitial, no "
-            "vendor marker, so there is no challenge to solve and no key "
-            "would help. What clears it, measured 2026-09-10: a residential "
-            "exit. The country does not matter — an Indonesian and a US "
-            "residential exit returned identical pages — but a datacentre "
-            "address gets nothing. Use --cdp-endpoint, or a residential "
-            "--proxy. This is exit 3, distinct from a genuinely empty result "
-            "(exit 4).%s",
-            len(html or ""), "which references" if served else "with no "
-            "reference to", debug_html,
-            (f" Tried {block_retries + 1} exit(s)." if has_pool
-             else f" Re-fetched {block_retries + 1} time(s)."))
+        logger.error("%s", page_flow.not_served_message(
+            html, headless=bool(getattr(args, "headless", False)),
+            has_pool=has_pool, tries=block_retries + 1,
+            debug_html=debug_html))
         outcome.blocked_by = "no-response" if not html else "not-served"
         outcome.final_url = session.page.url
         return outcome
@@ -967,21 +931,20 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
         if found <= threshold:
             # Not an error on its own, and what it MEANS depends on the
             # mode — which is why the message does too. A listing page with
-            # no grid is a correct answer (a taxonomy hub, or one page past
+            # no grid is a correct answer (a search that matches nothing, or one page past
             # the end); a detail page whose buy box never painted is a
             # different thing entirely, and on this site it is usually just
             # slow rather than absent, because the row is parsed out of the
-            # page's JSON-LD and not out of the buy box.
+            # page's __NEXT_DATA__ payload and not out of the buy box.
             if args.mode == "lot":
                 logger.info("The product name did not paint within %.0fs. "
-                            "That is not fatal: a detail row is read from the "
-                            "page's own Apollo cache and its price meta, both "
-                            "of which are in the first response, so the parse "
-                            "below decides.", content_timeout / 1000)
+                            "That is not fatal: a lot row is read from the "
+                            "page's own __NEXT_DATA__ payload, which is in the first "
+                            "response, so the parse below decides.", content_timeout / 1000)
             else:
                 logger.info("No listing tiles appeared within %.0fs. If this "
-                            "URL is a /p/<slug> discovery hub or one page "
-                            "past the end of a listing, that is the expected "
+                            "URL is one page past the end of a listing or a search "
+                            "with no matches, that is the expected "
                             "answer and the run will report 0 rows (exit 4).",
                             content_timeout / 1000)
 
@@ -1006,10 +969,9 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
     # is the "detected is not blocking" rule the captcha default follows,
     # applied to the blocking decision instead of the spending one. But
     # `state != "content"` is still too wide: an EMPTY page is a correct
-    # answer, and a live run of a /p/<slug> hub reported exit 3 on a 191 KB
-    # page the site had plainly served, because the hub's own performance
-    # script names `akamaihd.net` and "akamai" was in the marker list. Both
-    # halves were wrong; the marker is gone (see
+    # answer, and calling it blocked sends the reader hunting for a proxy
+    # problem that does not exist. A marker that fires on a served page is the
+    # same mistake; the marker set is narrowed (see
     # product_parser.BOT_CHALLENGE_MARKERS) and this now only refines the
     # REASON for a page the policy had already given up on.
     vendor = (detect_bot_challenge(html, url=session.page.url)
@@ -1059,13 +1021,10 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
         outcome.auction_facts = auction_metadata(html, session.page.url)
 
     # This site DOES publish a result total, in its own payload, so the
-    # arithmetic completeness check is available here. What it does not have
-    # is a printed header worth reading — the old note about
-    # untuk "kopi"" — and the total is empty on every capture; the range it
-    # does print is not a count of loaded rows either (it claimed 61-180
-    # while the DOM held 95). So the header is recorded verbatim and
-    # `total_available` stays None rather than carrying a number nobody can
-    # act on.
+    # arithmetic completeness check is available here. The page also
+    # states the query it ran, which is recorded for the sidecar; and
+    # `total_available` stays None when the payload states no total rather
+    # than carrying a number nobody can act on.
     if args.mode == "listing" and page_num == 1:
         outcome.total_available = total_results(html)
         outcome.header = search_header(html)
@@ -1098,10 +1057,8 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
         # and its absence is measured rather than an omission: the two sources
         # on this site are not two views of one number. The payload carries
         # everything except the money and the card carries only the money, so
-        # `price_source`
-        # is "dom" on every listing row and a confirmation threshold would
-        # describe nothing. Porting the sibling repo's would be dead code
-        # that looks load-bearing.
+        # a share of rows "confirmed" by a second source would describe
+        # nothing and be dead code that looks load-bearing.
         #
         # What IS worth reporting is how much of the grid had painted its
         # images, because that is the one column this site makes sparse on
@@ -1235,11 +1192,6 @@ def scrape(args) -> int:
     # result). "single_page_mode" is complete by construction — a detail page
     # has no page 2. Anything else is an early stop, and the run is only a
     # partial view.
-    # Only --mode product is single-page. A SHOP FRONT paginates exactly like
-    # a category listing — ?page=N, the same tiles — and treating it as
-    # single-page made `--mode shop --pages 2` fetch one page and report
-    # "complete", which is the silent-success failure this family exists to
-    # avoid. Found on the first live shop run.
     stop_reason = ("single_page_mode" if args.mode in ("lot", "auctions")
                    else "completed")
 
@@ -1253,7 +1205,7 @@ def scrape(args) -> int:
     concurrency = max(1, args.concurrency)
     if concurrency > 1:
         if args.mode == "lot":
-            logger.info("--concurrency is ignored in --mode product: there is "
+            logger.info("--concurrency is ignored in --mode lot: there is "
                         "one page to fetch.")
             concurrency = 1
         elif args.cdp_endpoint:
@@ -1405,18 +1357,15 @@ def scrape(args) -> int:
     # per-page check cannot see a gap BETWEEN two pages, which is exactly
     # where a short page hides.
     #
-    # NOT "pages x rows-per-page". This site's category page size is steady
-    # at 60, but a search page's row count depends on how far the scroll got
-    # before it settled, and the LAST page of any listing is legitimately
-    # short — so multiplying the fullest page by the page count would warn
-    # on healthy runs, and a threshold that fires on every healthy run
-    # teaches the reader to ignore it.
+    # NOT "pages x rows-per-page": the LAST page of a listing is legitimately
+    # short, so multiplying the fullest page by the page count would warn on
+    # healthy runs, and a threshold that fires on every healthy run teaches
+    # the reader to ignore it.
     #
     # What is worth warning about is a page that came back materially THIN
-    # against its siblings — that is what a truncated response or a
-    # half-painted grid looks like. A page holding less than 60% of the
-    # fullest page is well outside the +-3% spread that the varying page size
-    # accounts for.
+    # against the other pages of this run — that is what a truncated response
+    # or a half-painted grid looks like. A listing page holds 24 lots, so a
+    # page under 60% of the fullest page is well outside the normal spread.
     total_available = next((o.total_available for o in outcomes
                             if o.total_available is not None), None)
     if args.mode == "listing" and all_rows:
@@ -1464,36 +1413,12 @@ def scrape(args) -> int:
     final_url = (max(ok_pages, key=lambda o: o.page_num).final_url
                  if ok_pages else args.url)
 
-    # One-per-run context, in the sidecar rather than repeated down a column.
-    #
-    # In --mode product that is the seller's own id and name, off the page's
-    # Apollo cache. In --mode listing it is the scroll trace and the page's
-    # own result header: both say how much of the listing this run actually
-    # saw, which is the question a consumer of an infinitely-scrolling site
-    # most needs answered and which no column can carry.
+    # One-per-run context, in the sidecar rather than repeated down a column:
+    # for a search listing, the query the site says it ran.
     extra = None
-    if args.mode == "lot":
-        first = next((o for o in outcomes if o.ok and o.shop_facts), None)
-        if first is not None and first.shop_facts:
-            extra = dict(first.shop_facts)
-            logger.info("Shop: %s (id %s, /%s).",
-                        extra.get("shop_name") or "?",
-                        extra.get("shop_id") or "?",
-                        extra.get("shop_slug") or "?")
-    else:
-        scrolls = {o.page_num: o.scroll for o in outcomes if o.scroll}
-        headers = {o.page_num: o.header for o in outcomes if o.header}
-        unsettled = sorted(n for n, s in scrolls.items()
-                           if s and not s.get("settled"))
-        if scrolls or headers:
-            extra = {"scroll": scrolls, "result_header": headers,
-                     "pages_still_growing": unsettled}
-        if unsettled:
-            logger.warning(
-                "Page(s) %s were still loading more products when the scroll "
-                "budget ran out, so their row counts are floors rather than "
-                "the listing. Raise the budget or narrow the URL.",
-                ", ".join(str(n) for n in unsettled))
+    headers = {o.page_num: o.header for o in outcomes if o.header}
+    if headers:
+        extra = {"result_header": headers}
 
     return finish_run(all_rows, args.out, args.format, args.allow_empty,
                       blocked=blocked, stop_reason=stop_reason,
@@ -1507,46 +1432,15 @@ def scrape(args) -> int:
 def parse_args():
     p = argparse.ArgumentParser(
         description="Catawiki auction scraper (Playwright edition)")
-    p.add_argument("--url", default=None,
-                   help="A Catawiki URL: a category listing "
-                        "(/search?st=product&q=...), a category listing "
-                        "(/p/<cat>/<sub>[/<subsub>]) or one product "
-                        "(/{shop}/{slug}) with --mode product. One "
-                        "storefront, one language, one currency — there is "
-                        "no locale prefix and no per-country host. "
-                        "Required, unless CATAWIKI_URL is set in the environment "
-                        "or in .env.")
+    p.add_argument("--url", default=None, help=page_flow.URL_HELP)
     p.add_argument("--mode", choices=["listing", "lot", "auctions"],
-                   default="listing",
-                   help="listing (default): a search grid "
-                        "(/search?st=product&q=...) or a category listing "
-                        "(/p/<cat>/<sub>/<subsub>) — 60 products per batch. "
-                        "product: one /{shop}/{slug} page, read from the "
-                        "page's own Apollo cache, which adds the site's real "
-                        "product id, the EXACT sold count, the review count, "
-                        "the condition, the shipping weight and the "
-                        "category's own listing URL. --pages applies to "
-                        "listing only; there is one page to read in product "
-                        "mode. There is deliberately no shop mode: a "
-                        "shop front is a different application "
-                        "shell whose markup has not been measured, and a mode "
-                        "that ships untested is worse than one that is "
-                        "absent.")
+                   default="listing", help=page_flow.MODE_HELP)
     p.add_argument("--category", default=None,
                    help="Label to tag output rows with. Defaults to the "
-                        "category leaf from a /c/ URL, the search query from a "
-                        "/search URL, and the breadcrumb in --mode product, so "
-                        "the column is rarely empty just because the flag was "
-                        "omitted. A shop front spans categories and gets none, "
-                        "so pass one if you want that column filled.")
-    p.add_argument("--pages", type=int, default=1,
-                   help="Number of listing pages to crawl. Applies to "
-                        "--mode listing; ignored in --mode product, which "
-                        "has one page. Note that only a CATEGORY URL has "
-                        "per-page addresses: a search is one infinitely "
-                        "scrolling page, so --pages above 1 there is honoured "
-                        "by scrolling further rather than by fetching more "
-                        "URLs.")
+                        "category leaf from a /c/ URL and the search query "
+                        "from a /s URL, so the column is rarely empty just "
+                        "because the flag was omitted.")
+    p.add_argument("--pages", type=int, default=1, help=page_flow.PAGES_HELP)
     p.add_argument("--delay", type=float, default=2.0, help="Delay between pages, seconds")
     p.add_argument("--concurrency", type=int, default=1, metavar="N",
                    help="Fetch pages through N parallel workers (default 1 — "
@@ -1554,23 +1448,18 @@ def parse_args():
                         "own browser and holds its own proxy exit, so N>1 "
                         "without --proxy-file just sends N times the traffic "
                         "from one address. Ignored with --cdp-endpoint.")
-    p.add_argument("--retries", type=int, default=3,
-                   help="Attempts per page load before giving up (default 3). "
-                        "The pause between attempts doubles each time. A page "
-                        "that comes back EMPTY is not retried — see "
-                        "page_flow.STATE_POLICY — because an empty hub "
-                        "category is a correct answer, not a fault.")
+    p.add_argument("--retries", type=page_flow.attempts, default=3,
+                   help=page_flow.RETRIES_HELP)
     p.add_argument("--retry-delay", type=float, default=2.0,
                    help="Seconds before the first page-load retry, doubling "
                         "thereafter (default 2.0)")
     p.add_argument("--format", choices=["json", "csv", "both"], default="both")
     p.add_argument("--out", default="catawiki_products", help="Output file prefix")
     p.add_argument("--locale", default="id-ID",
-                   help="Browser locale (default id-ID, the site's only "
-                        "one). It does NOT decide the language or the "
-                        "currency: this site serves euro on all 18 locales and "
-                        "IDR prices to an Indonesian and a US exit alike, so "
-                        "this only affects what the browser claims about "
+                   help="Browser locale (default id-ID). It does NOT decide the "
+                        "language or the currency: the language is the URL's "
+                        "/{loc}/ segment and prices are euro on every locale, "
+                        "so this only affects what the browser claims about "
                         "itself.")
     p.add_argument("--proxy", default=None,
                    help="Proxy URL, e.g. http://ACCOUNT:PASSWORD@HOST:9999 "
@@ -1652,8 +1541,7 @@ def parse_args():
                    help="Save the exact HTML the parser is given, on success as "
                         "well as failure. Useful when the row count is right but "
                         "a column comes back empty — see TROUBLESHOOTING.md.")
-    # HEADFUL by default, a departure from every sibling repo and a measured
-    # one: Akamai refuses a headless browser here whatever the exit -- HTTP
+    # HEADFUL by default, and that is measured: Akamai refuses a headless browser here whatever the exit -- HTTP
     # 403 and a 394-byte "Access Denied" from four residential exits and one
     # datacentre address, against 200 and the full catalogue from those very
     # same addresses with a real window. A --headless default would be a
@@ -1688,25 +1576,9 @@ def parse_args():
                 f"storefront — one language, one currency, no per-country "
                 f"hostname and no locale prefix.")
     kind = listing_kind(args.url)
-    if args.mode == "lot" and kind != "lot":
-        p.error(f"--mode product expects a /{{shop}}/{{slug}} product URL; "
-                f"{args.url!r} is a {kind} page.")
-    if args.mode == "listing" and kind == "lot":
-        p.error(f"{args.url!r} is a single product page. Use --mode product "
-                f"for it, or pass a /search?st=product&q=... or "
-                f"/p/<cat>/<sub>/<subsub> URL.")
-    if args.mode == "listing" and kind == "hub":
-        # Said as a warning rather than an error: it IS a Catawiki URL and
-        # the run will honestly report zero rows (exit 4). But a reader who
-        # tries the obvious category URL first would otherwise conclude the
-        # tool is broken, so name what happened.
-        logger.warning(
-            "%s is a /p/<slug> DISCOVERY HUB, not a listing. It has no "
-            "product grid on it — only banners and recommendation carousels "
-            "— so this run will return 0 rows and exit 4. The real listings "
-            "are one or two levels down: /p/<cat>/<sub>[/<subsub>], e.g. "
-            "/p/makanan-minuman/minuman/kopi-bubuk. A product page's own "
-            "breadcrumb names its category's listing URL.", args.url)
+    mismatch = page_flow.mode_url_mismatch(args.mode, args.url, kind)
+    if mismatch:
+        p.error(mismatch)
     if args.mode in ("lot", "auctions") and args.pages != 1:
         # Said out loud rather than silently ignored: a user who passed
         # --pages 5 expects five pages of something.
diff --git a/product_parser.py b/product_parser.py
index 2f2069f..f921d8a 100644
--- a/product_parser.py
+++ b/product_parser.py
@@ -563,11 +563,9 @@ def price_in(text: str) -> Optional[float]:
 )
 
 # Catawiki rendered none of these to an anonymous visitor across 19 captures
-# and 6 locales, and -- unlike a sibling repo in this family -- it ships no
-# captcha mount point and no site key in its page config either
-# (`<captcha-widgets>` and `CAPTCHA_SITE_KEY`: 0 occurrences on every
-# capture). Those are another site's findings and were checked before being
-# believed here. This set is therefore forward-looking: the shapes a
+# and 6 locales, and it ships no captcha mount point and no site key in its
+# page config either (`<captcha-widgets>` and `CAPTCHA_SITE_KEY`: 0
+# occurrences on every capture). This set is therefore forward-looking: the shapes a
 # challenge WOULD take, kept so that an appearance is recognised instead of
 # being reported as an empty page.
 BOT_CHALLENGE_MARKERS = (
diff --git a/puppeteer_scraper.py b/puppeteer_scraper.py
index 5710c10..f8706dd 100644
--- a/puppeteer_scraper.py
+++ b/puppeteer_scraper.py
@@ -215,16 +215,8 @@ class PageOutcome:
     # Populated here: the SSR payload states `total` and `lotsPerPage` on
     # page 1, which is what makes the page count arithmetic.
     total_available: Optional[int] = None
-    # The raw result-count header, verbatim, for the sidecar.
+    # The query a search page ran, read from its payload, for the sidecar.
     header: Optional[str] = None
-    # What the lazy-load scroll did, and crucially whether it SETTLED. A page
-    # whose grid was still growing when the budget ran out is partial, and a
-    # run that reported it as complete would read as a shrinking catalogue.
-    scroll: Optional[dict] = None
-    # In --mode product, the seller's own id/name/slug from the page's Apollo
-    # cache. Stored as the small dict rather than by keeping the page's HTML
-    # around: a detail page is 285 KB and a scrolled listing nearly 1 MB.
-    shop_facts: Optional[dict] = None
 
     @property
     def ok(self) -> bool:
@@ -404,13 +396,11 @@ def _same_url(a: str, b: str) -> bool:
     """Whether two URLs address the same page.
 
     Delegates to page_flow rather than reimplementing the comparison, so all
-    three engines cannot drift on it. On this site the comparison has to
-    strip a long tracking tail: a listing anchor arrives with
-    `?extParam=…keyword=kopi&search_id=…&src=search` and a detail page's own
-    canonical arrives with a UTM triple, so two views of one page never
-    match unless both sides are cleaned. An engine with its own copy of
-    this in a sibling repo got the equivalent wrong and silently fell back
-    to sequential fetching.
+    three engines cannot drift on it. Links the site generates can
+    carry tracking parameters that a canonical address does not, so two
+    views of one page never match unless both sides are cleaned. An engine
+    with its own copy of this can go stale and silently fall back to
+    sequential fetching.
     """
     return page_flow.comparable(a) == page_flow.comparable(b)
 
@@ -419,9 +409,9 @@ def _next_page_candidates(session, page_num: int) -> List[str]:
     """The site's own next-page link, resolved, or None.
 
     Returns EVERY candidate, filtered by page_flow to the ones that really do
-    paginate this listing: a shop front advertises its REVIEWS pagination
-    alongside its items, and following that one returns rows from the wrong
-    listing while reporting success.
+    paginate this listing: a page can advertise other paginated lists
+    alongside its lots, and following one of those returns rows from the
+    wrong listing while reporting success.
 
     Reads the DOM's `.href` property rather than the raw attribute, which the
     browser has already resolved — the opposite of Playwright's
@@ -603,14 +593,16 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
 
         if not page_flow.should_retry(state):
             # "content" and "empty" are both final answers. An empty page is
-            # a CORRECT one — a hub category has no grid — so retrying it
+            # a CORRECT one — an empty listing has no grid — so retrying it
             # would re-confirm the same right answer, and rotating the exit
             # would blame an address for the URL it was given.
             break
 
-        # Blocked or challenged. The ADDRESS is what was scored, not the URL,
-        # so a different exit is the only thing that plausibly changes the
-        # outcome.
+        # Blocked or challenged. The retry budget is 0 here
+        # (page_flow.BLOCK_RETRIES_*): this site refuses a headless browser
+        # whatever the exit, so a second attempt from another address would
+        # spend the budget on a change that cannot help. The branch stays so
+        # the budget, not the code path, is what a future measurement edits.
         if block_attempt < block_retries:
             logger.warning("Page %d came back as %s from %s — retrying from "
                            "another exit (%d/%d).", page_num, state,
@@ -637,16 +629,10 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
         debug_html = f"{args.out}_page{page_num}_debug.html"
         with open(debug_html, "w", encoding="utf-8") as f:
             f.write(html or "")
-        logger.error(
-            "The site did not serve this request — %d bytes, %s the site's "
-            "own asset host, saved to %s. There is no challenge to solve. "
-            "What clears it, measured 2026-09-10: a HEADFUL browser, and the "
-            "exit address does not matter (four residential exits and one "
-            "returned identical pages) — a datacentre address gets nothing. "
-            "This is exit 3, distinct from a genuinely empty result (exit 4).",
-            len(html or ""),
-            "which references" if served_by_catawiki(html or "")
-            else "with no reference to", debug_html)
+        logger.error("%s", page_flow.not_served_message(
+            html, headless=bool(getattr(args, "headless", False)),
+            has_pool=has_pool, tries=block_retries + 1,
+            debug_html=debug_html))
         outcome.blocked_by = "no-response" if not html else "not-served"
         outcome.final_url = d["current_url"]()
         return outcome
@@ -672,20 +658,20 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
         if found <= threshold:
             # Not an error on its own, and what it MEANS depends on the
             # mode — which is why the message does too. A listing page with
-            # no grid is a correct answer (a taxonomy hub, or one page past
+            # no grid is a correct answer (a search that matches nothing, or one page past
             # the end); a detail page whose buy box never painted is a
             # different thing entirely, and on this site it is usually just
             # slow rather than absent, because the row is parsed out of the
-            # page's JSON-LD and not out of the buy box.
+            # page's __NEXT_DATA__ payload and not out of the buy box.
             if args.mode == "lot":
                 logger.info("The product name did not paint in time. That is "
-                            "not fatal: a detail row is read from the page's "
-                            "own Apollo cache and its price meta, both in the "
-                            "first response, so the parse below decides.")
+                            "not fatal: a lot row is read from the page's own "
+                            "__NEXT_DATA__ payload, which is in the first "
+                            "response, so the parse below decides.")
             else:
                 logger.info("No listing tiles appeared in time. If this URL "
-                            "is a /p/<slug> discovery hub or one page past "
-                            "the end of a listing, that is the expected "
+                            "is one page past the end of a listing or a search "
+                            "with no matches, that is the expected "
                             "answer and the run will report 0 rows (exit 4).")
 
         html = d["content"]() or html
@@ -699,10 +685,8 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
                     dump_path, len(html))
 
     # Only for a state page_flow already counts as BLOCKED. An EMPTY
-    # page is a correct answer, and a live run of a /p/<slug> hub
-    # reported exit 3 on a page the site had plainly served because the
-    # hub's own performance script names `akamaihd.net`. Mirrors
-    # playwright_scraper exactly.
+    # page is a correct answer, and calling it blocked sends the reader hunting for a
+    # proxy problem that does not exist. Mirrors playwright_scraper exactly.
     vendor = (detect_bot_challenge(html, url=page.url)
               if page_flow.counts_as_blocked(state) else None)
     if vendor:
@@ -815,11 +799,6 @@ def scrape(args) -> int:
     blocked = False
     # Both modes are one row per product, so `sku` is the key for both.
     dedupe_key = "sku"
-    # Only --mode product is single-page. A SHOP FRONT paginates exactly like
-    # a category listing — ?page=N, the same tiles — and treating it as
-    # single-page made `--mode shop --pages 2` fetch one page and report
-    # "complete", which is the silent-success failure this family exists to
-    # avoid. Found on the first live shop run.
     stop_reason = "single_page_mode" if args.mode in ("lot", "auctions") else "completed"
 
     pool = proxy_pool_from_args(args)
@@ -925,18 +904,15 @@ def scrape(args) -> int:
     # per-page check cannot see a gap BETWEEN two pages, which is exactly
     # where a short page hides.
     #
-    # NOT "pages x rows-per-page", which is what the sibling repo does and
-    # what fires on healthy runs here. This site's page size is steady:
-    # a three-page run returned 62, 60 and 62 rows, and multiplying the
-    # largest page by the page count then declared the run short by 8. A
-    # threshold that warns on every healthy run teaches the reader to ignore
-    # it.
+    # NOT "pages x rows-per-page": the LAST page of a listing is legitimately
+    # short, so multiplying the fullest page by the page count would warn on
+    # healthy runs, and a threshold that fires on every healthy run teaches
+    # the reader to ignore it.
     #
     # What is worth warning about is a page that came back materially THIN
-    # against its siblings — that is what a truncated response or a
-    # half-painted grid looks like. A page holding less than 60% of the
-    # fullest page is well outside the +-3% spread that the varying page size
-    # accounts for.
+    # against the other pages of this run — that is what a truncated response
+    # or a half-painted grid looks like. A listing page holds 24 lots, so a
+    # page under 60% of the fullest page is well outside the normal spread.
     total_available = next((o.total_available for o in outcomes
                             if o.total_available is not None), None)
     if args.mode == "listing" and all_rows:
@@ -983,33 +959,12 @@ def scrape(args) -> int:
     final_url = (max(ok_pages, key=lambda o: o.page_num).final_url
                  if ok_pages else args.url)
 
-    # One-per-run context, in the sidecar rather than repeated down a column.
-    # Mirrors the Playwright engine exactly: the seller's own facts in
-    # --mode product, and the scroll trace plus the page's own result header
-    # in --mode listing, because on an infinitely-scrolling site those are
-    # what say how much of the listing the run actually saw.
+    # One-per-run context, in the sidecar rather than repeated down a column:
+    # for a search listing, the query the site says it ran.
     extra = None
-    if args.mode == "lot":
-        first = next((o for o in outcomes if o.ok and o.shop_facts), None)
-        if first is not None and first.shop_facts:
-            extra = dict(first.shop_facts)
-            logger.info("Shop: %s (id %s, /%s).",
-                        extra.get("shop_name") or "?",
-                        extra.get("shop_id") or "?",
-                        extra.get("shop_slug") or "?")
-    else:
-        scrolls = {o.page_num: o.scroll for o in outcomes if o.scroll}
-        headers = {o.page_num: o.header for o in outcomes if o.header}
-        unsettled = sorted(n for n, s in scrolls.items()
-                           if s and not s.get("settled"))
-        if scrolls or headers:
-            extra = {"scroll": scrolls, "result_header": headers,
-                     "pages_still_growing": unsettled}
-        if unsettled:
-            logger.warning(
-                "Page(s) %s were still loading more products when the scroll "
-                "budget ran out, so their row counts are floors rather than "
-                "the listing.", ", ".join(str(n) for n in unsettled))
+    headers = {o.page_num: o.header for o in outcomes if o.header}
+    if headers:
+        extra = {"result_header": headers}
 
     return finish_run(all_rows, args.out, args.format, args.allow_empty,
                       blocked=blocked, stop_reason=stop_reason,
@@ -1025,30 +980,17 @@ def parse_args():
         description="Catawiki auction scraper (pyppeteer edition). pyppeteer is "
                     "effectively unmaintained — playwright_scraper.py is the "
                     "primary engine.")
-    p.add_argument("--url", default=None,
-                   help="A Catawiki URL: /{loc}/c/{id}-{slug}, /{loc}/s?q=..., "
-                        "/p/<cat>/<sub>/<subsub>, or /{shop}/{slug} with "
-                        "--mode product. Required, unless CATAWIKI_URL is "
-                        "set in the environment or in .env.")
+    p.add_argument("--url", default=None, help=page_flow.URL_HELP)
     p.add_argument("--mode", choices=["listing", "lot", "auctions"],
-                   default="listing",
-                   help="listing (default) or product. product reads one "
-                        "/{shop}/{slug} page out of its own Apollo cache and "
-                        "adds the site's real product id, the EXACT sold "
-                        "count, the review count, the condition and the "
-                        "shipping weight — the columns a listing row cannot "
-                        "carry. No --pages in product mode. There is "
-                        "deliberately no shop mode; see playwright_scraper.")
+                   default="listing", help=page_flow.MODE_HELP)
     p.add_argument("--category", default=None, help="Label to tag output rows with.")
-    p.add_argument("--pages", type=int, default=1, help="Listing pages to crawl")
+    p.add_argument("--pages", type=int, default=1, help=page_flow.PAGES_HELP)
     p.add_argument("--delay", type=float, default=2.0, help="Delay between pages, seconds")
     p.add_argument("--concurrency", type=int, default=1, metavar="N",
                    help="Accepted for flag parity and IGNORED here: parallel "
                         "page fetching lives in playwright_scraper.py.")
-    p.add_argument("--retries", type=int, default=3,
-                   help="Attempts per page load before giving up (default 3). "
-                        "A page that comes back EMPTY is not retried: an empty "
-                        "hub category is a correct answer, not a fault.")
+    p.add_argument("--retries", type=page_flow.attempts, default=3,
+                   help=page_flow.RETRIES_HELP)
     p.add_argument("--retry-delay", type=float, default=2.0,
                    help="Seconds before the first retry, doubling thereafter")
     p.add_argument("--format", choices=["json", "csv", "both"], default="both")
@@ -1096,8 +1038,7 @@ def parse_args():
                         "code at all, so it is the build, not this engine). "
                         "Point it at a Chrome or Chromium of your own — "
                         "Playwright's, if you have it installed.")
-    # HEADFUL by default, a departure from every sibling repo and a measured
-    # one: Akamai refuses a headless browser here whatever the exit -- HTTP
+    # HEADFUL by default, and that is measured: Akamai refuses a headless browser here whatever the exit -- HTTP
     # 403 and a 394-byte "Access Denied" from four residential exits and one
     # datacentre address, against 200 and the full catalogue from those same
     # addresses with a real window.
@@ -1131,19 +1072,9 @@ def parse_args():
                 f"storefront — one language, one currency, no per-country "
                 f"hostname and no locale prefix.")
     kind = listing_kind(args.url)
-    if args.mode == "lot" and kind != "lot":
-        p.error(f"--mode product expects a /{{shop}}/{{slug}} product URL; "
-                f"{args.url!r} is a {kind} page.")
-    if args.mode == "listing" and kind == "lot":
-        p.error(f"{args.url!r} is a single product page. Use --mode product "
-                f"for it, or pass a /search?st=product&q=... or "
-                f"/p/<cat>/<sub>/<subsub> URL.")
-    if args.mode == "listing" and kind == "hub":
-        logger.warning(
-            "%s is a /p/<slug> DISCOVERY HUB, not a listing — no product "
-            "grid, only banners and recommendation carousels — so this run "
-            "will return 0 rows and exit 4. The real listings are one or two "
-            "levels down: /p/<cat>/<sub>[/<subsub>].", args.url)
+    mismatch = page_flow.mode_url_mismatch(args.mode, args.url, kind)
+    if mismatch:
+        p.error(mismatch)
     return args
 
 
diff --git a/scraper_api_client.py b/scraper_api_client.py
index 4bba874..2645b62 100644
--- a/scraper_api_client.py
+++ b/scraper_api_client.py
@@ -27,7 +27,7 @@
 browser engine when you want the bids. Every row it writes says so itself:
 `price_source` is `next_data`, never `next_data+dom`.
 
-Unlike the sibling repos, this path needs no `--cdp-url` to reach the site at
+This path needs no `--cdp-url` to reach the site at
 all: the plain Scraper API request was served. Akamai refuses a HEADLESS
 BROWSER here, not a datacentre address, and this client is not a browser.
 
@@ -305,10 +305,8 @@ def parse_args():
                    help="2captcha.com API key (sent as a Bearer token). "
                         "Defaults to $TWOCAPTCHA_KEY, which is the safer way to pass it.")
     p.add_argument("--url", default=None,
-                   help="A Catawiki listing URL — a category listing "
-                        "(/p/<cat>/<sub>/<subsub>) is the only kind this path "
-                        "can read at all, since a search grid has no "
-                        "server-rendered container. Required, unless "
+                   help="A Catawiki listing URL, e.g. a category "
+                        "/{loc}/c/{id}-{slug}. Required, unless "
                         "CATAWIKI_URL is set in the environment or in .env.")
     p.add_argument("--category", default=None, help="Label to tag output rows with. Defaults to the category segment of the URL, so the column is never empty just because the flag was omitted.")
     p.add_argument("--format", choices=["json", "csv", "both"], default="both")
diff --git a/selenium_scraper.py b/selenium_scraper.py
index 56e49a8..bcc84f5 100644
--- a/selenium_scraper.py
+++ b/selenium_scraper.py
@@ -120,14 +120,8 @@ class PageOutcome:
     # Populated here: the SSR payload states `total` and `lotsPerPage` on
     # page 1, which is what makes the page count arithmetic.
     total_available: Optional[int] = None
-    # The raw result-count header, verbatim, for the sidecar.
+    # The query a search page ran, read from its payload, for the sidecar.
     header: Optional[str] = None
-    # What the lazy-load scroll did, and crucially whether it SETTLED. A page
-    # whose grid was still growing when the budget ran out is partial.
-    scroll: Optional[dict] = None
-    # In --mode product, the seller's own id/name/slug from the page's Apollo
-    # cache.
-    shop_facts: Optional[dict] = None
 
     @property
     def ok(self) -> bool:
@@ -378,9 +372,9 @@ def _next_page_candidates(session, page_num: int) -> List[str]:
     """The site's own next-page link, resolved by the browser, or None.
 
     Returns EVERY candidate, filtered by page_flow to the ones that really do
-    paginate this listing: a shop front advertises its REVIEWS pagination
-    alongside its items, and following that one returns rows from the wrong
-    listing while reporting success.
+    paginate this listing: a page can advertise other paginated lists
+    alongside its lots, and following one of those returns rows from the
+    wrong listing while reporting success.
 
     Reads the DOM's `.href` property, which is already absolute — the
     opposite of Playwright's get_attribute("href"), which returns the raw
@@ -573,14 +567,16 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
 
         if not page_flow.should_retry(state):
             # "content" and "empty" are both final answers. An empty page is
-            # a CORRECT one — a hub category has no grid — so retrying it
+            # a CORRECT one — an empty listing has no grid — so retrying it
             # would re-confirm the same right answer, and rotating the exit
             # would blame an address for the URL it was given.
             break
 
-        # Blocked or challenged. The ADDRESS is what was scored, not the URL,
-        # so a different exit is the only thing that plausibly changes the
-        # outcome.
+        # Blocked or challenged. The retry budget is 0 here
+        # (page_flow.BLOCK_RETRIES_*): this site refuses a headless browser
+        # whatever the exit, so a second attempt from another address would
+        # spend the budget on a change that cannot help. The branch stays so
+        # the budget, not the code path, is what a future measurement edits.
         if block_attempt < block_retries:
             logger.warning("Page %d came back as %s from %s — retrying from "
                            "another exit (%d/%d).", page_num, state,
@@ -605,18 +601,10 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
         debug_html = f"{args.out}_page{page_num}_debug.html"
         with open(debug_html, "w", encoding="utf-8") as f:
             f.write(html or "")
-        logger.error(
-            "The site did not serve this request — %d bytes, %s the site's "
-            "own asset host, saved to %s. There is no challenge to solve. "
-            "What clears it, measured 2026-09-10: a HEADFUL browser, and the "
-            "exit address does not matter (four residential exits and one "
-            "returned identical pages) — a datacentre address gets nothing. "
-            "Note this engine cannot use an authenticated remote CDP endpoint "
-            "or an authenticated proxy; see the README's engine limits. This "
-            "is exit 3, distinct from a genuinely empty result (exit 4).",
-            len(html or ""),
-            "which references" if served_by_catawiki(html or "")
-            else "with no reference to", debug_html)
+        logger.error("%s", page_flow.not_served_message(
+            html, headless=bool(getattr(args, "headless", False)),
+            has_pool=has_pool, tries=block_retries + 1,
+            debug_html=debug_html))
         outcome.blocked_by = "no-response" if not html else "not-served"
         outcome.final_url = d["current_url"]()
         return outcome
@@ -643,21 +631,21 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
         if found <= threshold:
             # Not an error on its own, and what it MEANS depends on the
             # mode — which is why the message does too. A listing page with
-            # no grid is a correct answer (a taxonomy hub, or one page past
+            # no grid is a correct answer (a search that matches nothing, or one page past
             # the end); a detail page whose buy box never painted is a
             # different thing entirely, and on this site it is usually just
             # slow rather than absent, because the row is parsed out of the
-            # page's JSON-LD and not out of the buy box.
+            # page's __NEXT_DATA__ payload and not out of the buy box.
             if args.mode == "lot":
                 logger.info("The product name did not paint within %.0fs. "
-                            "That is not fatal: a detail row is read from the "
-                            "page's own Apollo cache and its price meta, both "
-                            "in the first response, so the parse below "
+                            "That is not fatal: a lot row is read from the "
+                            "page's own __NEXT_DATA__ payload, which is in the first "
+                            "response, so the parse below "
                             "decides.", timeout_s)
             else:
                 logger.info("No listing tiles appeared within %.0fs. If this "
-                            "URL is a /p/<slug> discovery hub or one page "
-                            "past the end of a listing, that is the expected "
+                            "URL is one page past the end of a listing or a search "
+                            "with no matches, that is the expected "
                             "answer and the run will report 0 rows (exit 4).",
                             timeout_s)
 
@@ -676,9 +664,8 @@ def _fetch_one_page(session, args, pool, page_num: int, url: str) -> PageOutcome
     # --cdp-endpoint the Scraping Browser's own auto-solve extension injects
     # such markers into every page it loads.
     # Only for a state page_flow already counts as BLOCKED. An EMPTY page is
-    # a correct answer, and a live run of a /p/<slug> hub reported exit 3 on
-    # a page the site had plainly served because the hub's own performance
-    # script names `akamaihd.net`. Mirrors playwright_scraper exactly.
+    # a correct answer, and calling it blocked sends the reader hunting for a
+    # proxy problem that does not exist. Mirrors playwright_scraper exactly.
     vendor = (detect_bot_challenge(html, url=d["current_url"]())
               if page_flow.counts_as_blocked(state) else None)
     if vendor:
@@ -780,11 +767,6 @@ def scrape(args) -> int:
     blocked = False
     # Both modes are one row per product, so `sku` is the key for both.
     dedupe_key = "sku"
-    # Only --mode product is single-page. A SHOP FRONT paginates exactly like
-    # a category listing — ?page=N, the same tiles — and treating it as
-    # single-page made `--mode shop --pages 2` fetch one page and report
-    # "complete", which is the silent-success failure this family exists to
-    # avoid. Found on the first live shop run.
     stop_reason = "single_page_mode" if args.mode in ("lot", "auctions") else "completed"
 
     pool = proxy_pool_from_args(args)
@@ -885,18 +867,15 @@ def scrape(args) -> int:
     # per-page check cannot see a gap BETWEEN two pages, which is exactly
     # where a short page hides.
     #
-    # NOT "pages x rows-per-page", which is what the sibling repo does and
-    # what fires on healthy runs here. This site's page size is steady:
-    # a three-page run returned 62, 60 and 62 rows, and multiplying the
-    # largest page by the page count then declared the run short by 8. A
-    # threshold that warns on every healthy run teaches the reader to ignore
-    # it.
+    # NOT "pages x rows-per-page": the LAST page of a listing is legitimately
+    # short, so multiplying the fullest page by the page count would warn on
+    # healthy runs, and a threshold that fires on every healthy run teaches
+    # the reader to ignore it.
     #
     # What is worth warning about is a page that came back materially THIN
-    # against its siblings — that is what a truncated response or a
-    # half-painted grid looks like. A page holding less than 60% of the
-    # fullest page is well outside the +-3% spread that the varying page size
-    # accounts for.
+    # against the other pages of this run — that is what a truncated response
+    # or a half-painted grid looks like. A listing page holds 24 lots, so a
+    # page under 60% of the fullest page is well outside the normal spread.
     total_available = next((o.total_available for o in outcomes
                             if o.total_available is not None), None)
     if args.mode == "listing" and all_rows:
@@ -943,33 +922,12 @@ def scrape(args) -> int:
     final_url = (max(ok_pages, key=lambda o: o.page_num).final_url
                  if ok_pages else args.url)
 
-    # One-per-run context, in the sidecar rather than repeated down a column.
-    # Mirrors the other two engines exactly: the seller's own facts in
-    # --mode product, and the scroll trace plus the page's own result header
-    # in --mode listing, because on an infinitely-scrolling site those are
-    # what say how much of the listing the run actually saw.
+    # One-per-run context, in the sidecar rather than repeated down a column:
+    # for a search listing, the query the site says it ran.
     extra = None
-    if args.mode == "lot":
-        first = next((o for o in outcomes if o.ok and o.shop_facts), None)
-        if first is not None and first.shop_facts:
-            extra = dict(first.shop_facts)
-            logger.info("Shop: %s (id %s, /%s).",
-                        extra.get("shop_name") or "?",
-                        extra.get("shop_id") or "?",
-                        extra.get("shop_slug") or "?")
-    else:
-        scrolls = {o.page_num: o.scroll for o in outcomes if o.scroll}
-        headers = {o.page_num: o.header for o in outcomes if o.header}
-        unsettled = sorted(n for n, s in scrolls.items()
-                           if s and not s.get("settled"))
-        if scrolls or headers:
-            extra = {"scroll": scrolls, "result_header": headers,
-                     "pages_still_growing": unsettled}
-        if unsettled:
-            logger.warning(
-                "Page(s) %s were still loading more products when the scroll "
-                "budget ran out, so their row counts are floors rather than "
-                "the listing.", ", ".join(str(n) for n in unsettled))
+    headers = {o.page_num: o.header for o in outcomes if o.header}
+    if headers:
+        extra = {"result_header": headers}
 
     return finish_run(all_rows, args.out, args.format, args.allow_empty,
                       blocked=blocked, stop_reason=stop_reason,
@@ -985,30 +943,17 @@ def parse_args():
         description="Catawiki auction scraper (Selenium edition). Cannot authenticate a "
                     "proxy or a remote CDP endpoint — see the module "
                     "docstring; playwright_scraper.py is the primary engine.")
-    p.add_argument("--url", default=None,
-                   help="A Catawiki URL: /{loc}/c/{id}-{slug}, /{loc}/s?q=..., "
-                        "/p/<cat>/<sub>/<subsub>, or /{shop}/{slug} with "
-                        "--mode product. Required, unless CATAWIKI_URL is "
-                        "set in the environment or in .env.")
+    p.add_argument("--url", default=None, help=page_flow.URL_HELP)
     p.add_argument("--mode", choices=["listing", "lot", "auctions"],
-                   default="listing",
-                   help="listing (default) or product. product reads one "
-                        "/{shop}/{slug} page out of its own Apollo cache and "
-                        "adds the site's real product id, the EXACT sold "
-                        "count, the review count, the condition and the "
-                        "shipping weight — the columns a listing row cannot "
-                        "carry. No --pages in product mode. There is "
-                        "deliberately no shop mode; see playwright_scraper.")
+                   default="listing", help=page_flow.MODE_HELP)
     p.add_argument("--category", default=None, help="Label to tag output rows with.")
-    p.add_argument("--pages", type=int, default=1, help="Listing pages to crawl")
+    p.add_argument("--pages", type=int, default=1, help=page_flow.PAGES_HELP)
     p.add_argument("--delay", type=float, default=2.0, help="Delay between pages, seconds")
     p.add_argument("--concurrency", type=int, default=1, metavar="N",
                    help="Accepted for flag parity and IGNORED here: parallel "
                         "page fetching lives in playwright_scraper.py.")
-    p.add_argument("--retries", type=int, default=3,
-                   help="Attempts per page load before giving up (default 3). "
-                        "A page that comes back EMPTY is not retried: an empty "
-                        "hub category is a correct answer, not a fault.")
+    p.add_argument("--retries", type=page_flow.attempts, default=3,
+                   help=page_flow.RETRIES_HELP)
     p.add_argument("--retry-delay", type=float, default=2.0,
                    help="Seconds before the first retry, doubling thereafter")
     p.add_argument("--format", choices=["json", "csv", "both"], default="both")
@@ -1066,8 +1011,7 @@ def parse_args():
     p.add_argument("--dump-html", default=None, metavar="PATH",
                    help="Save the exact HTML the parser is given, on success "
                         "as well as failure.")
-    # HEADFUL by default, a departure from every sibling repo and a measured
-    # one: Akamai refuses a headless browser here whatever the exit -- HTTP
+    # HEADFUL by default, and that is measured: Akamai refuses a headless browser here whatever the exit -- HTTP
     # 403 and a 394-byte "Access Denied" from four residential exits and one
     # datacentre address, against 200 and the full catalogue from those same
     # addresses with a real window.
@@ -1101,19 +1045,9 @@ def parse_args():
                 f"storefront — one language, one currency, no per-country "
                 f"hostname and no locale prefix.")
     kind = listing_kind(args.url)
-    if args.mode == "lot" and kind != "lot":
-        p.error(f"--mode product expects a /{{shop}}/{{slug}} product URL; "
-                f"{args.url!r} is a {kind} page.")
-    if args.mode == "listing" and kind == "lot":
-        p.error(f"{args.url!r} is a single product page. Use --mode product "
-                f"for it, or pass a /search?st=product&q=... or "
-                f"/p/<cat>/<sub>/<subsub> URL.")
-    if args.mode == "listing" and kind == "hub":
-        logger.warning(
-            "%s is a /p/<slug> DISCOVERY HUB, not a listing — no product "
-            "grid, only banners and recommendation carousels — so this run "
-            "will return 0 rows and exit 4. The real listings are one or two "
-            "levels down: /p/<cat>/<sub>[/<subsub>].", args.url)
+    mismatch = page_flow.mode_url_mismatch(args.mode, args.url, kind)
+    if mismatch:
+        p.error(mismatch)
     return args
 
 
diff --git a/smoke_test.py b/smoke_test.py
index 39bb2a6..bb4514c 100644
--- a/smoke_test.py
+++ b/smoke_test.py
@@ -726,11 +726,102 @@ def test_page_flow():
     # headful one was served from the same addresses. The budget is 0 on
     # purpose, and the engines read these constants rather than computing
     # their own.
-    ok &= check("RETRY_ON_BLOCKED is False, against True in the siblings",
+    ok &= check("RETRY_ON_BLOCKED is False",
                 page_flow.RETRY_ON_BLOCKED is False)
     ok &= check("and the block-retry budgets are 0",
                 page_flow.BLOCK_RETRIES_WITHOUT_POOL == 0
                 and page_flow.BLOCK_RETRIES_WITH_POOL == 0)
+    # --retries 0 used to skip navigation entirely (range(1, 0 + 1) is empty),
+    # so the engine judged about:blank: a 39-byte empty DOM reported as
+    # "blocked", exit 3, for a site that was never asked. Found by an audit
+    # whose own live run used --retries 0 and read that as a block.
+    import argparse as _ap
+    ok &= check("--retries accepts 1 and 3",
+                page_flow.attempts("1") == 1 and page_flow.attempts("3") == 3)
+    for bad in ("0", "-1", "x"):
+        try:
+            page_flow.attempts(bad)
+            raised = False
+        except _ap.ArgumentTypeError:
+            raised = True
+        ok &= check("--retries %s is refused as a usage error" % bad, raised)
+    for eng in ("playwright", "selenium", "puppeteer"):
+        src = open(os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                eng + "_scraper.py"), encoding="utf-8").read()
+        ok &= check("%s: --retries goes through page_flow.attempts" % eng,
+                    '"--retries", type=page_flow.attempts' in src)
+        ok &= check("%s: the not-served log is the shared message" % eng,
+                    "page_flow.not_served_message(" in src)
+
+    # An empty DOM is not Akamai's refusal, and the message must not say so.
+    empty = "<html><head></head><body></body></html>"
+    m = page_flow.not_served_message(empty, headless=False, has_pool=False,
+                                     tries=1, debug_html="x.html")
+    ok &= check("a headful empty DOM is called a navigation that did not "
+                "complete, not a refusal, and does not blame headless",
+                "empty document" in m and "--retries" in m
+                and "HEADLESS" not in m and "proxy" not in m.lower())
+    m = page_flow.not_served_message(empty, headless=True, has_pool=False,
+                                     tries=1, debug_html="x.html")
+    ok &= check("a headless empty DOM also names headless", "HEADLESS" in m)
+    m = page_flow.not_served_message(BLOCKED_403, headless=False,
+                                     has_pool=False, tries=1,
+                                     debug_html="x.html")
+    ok &= check("a headful refusal page is not blamed on headless",
+                "headful" in m and "HEADLESS" not in m
+                and "empty document" not in m)
+
+    ok &= check("--mode lot on a category URL is a usage error naming lot",
+                "--mode lot" in (page_flow.mode_url_mismatch(
+                    "lot", "https://www.catawiki.com/en/c/333-watches",
+                    "category") or ""))
+    ok &= check("a lot URL in listing mode points at --mode lot, not product",
+                "Use --mode lot" in (page_flow.mode_url_mismatch(
+                    "listing", "https://www.catawiki.com/en/l/1-x", "lot")
+                    or ""))
+    ok &= check("a matching mode and URL is accepted",
+                page_flow.mode_url_mismatch("listing", "u", "category") is None)
+
+    # The user-facing text of all three engines must describe THIS site. It
+    # was inherited from a different marketplace scraper (a product mode, an
+    # URL kinds, modes and currency), and a reader following --help sent
+    # the wrong URL kind and the wrong mode.
+    import ast as _ast
+    stale = ("st=product", "--mode product", "Apollo", "/p/<", "IDR ",
+             "discovery hub", "/{shop}")
+    for eng in ("playwright", "selenium", "puppeteer"):
+        path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                            eng + "_scraper.py")
+        tree = _ast.parse(open(path, encoding="utf-8").read())
+        hits = sorted({t for n in _ast.walk(tree)
+                       if isinstance(n, _ast.Constant) and isinstance(n.value, str)
+                       for t in stale if t in n.value})
+        ok &= check("%s: no stale marketplace wording in its strings %s"
+                    % (eng, hits or ""), not hits)
+    for name in ("URL_HELP", "MODE_HELP", "PAGES_HELP", "RETRIES_HELP"):
+        txt = getattr(page_flow, name)
+        ok &= check("page_flow.%s has no stale wording" % name,
+                    not any(t in txt for t in stale))
+
+    # diff_runs refused every --mode lot run: the allowed-mode list named a
+    # mode ("product") this repo does not have, so a lot run's sidecar was
+    # rejected as "a mode that cannot be diffed".
+    import output_writer as _ow
+    ok &= check("lot and listing runs are diffable; auctions rows are not",
+                "lot" in _ow.UNIQUE_BY_SKU_MODES
+                and "listing" in _ow.UNIQUE_BY_SKU_MODES
+                and "auctions" not in _ow.UNIQUE_BY_SKU_MODES
+                and "product" not in _ow.UNIQUE_BY_SKU_MODES)
+    ok &= check("every mode an engine accepts has a row class",
+                set(_ow.ROW_CLASS_BY_MODE) == {"listing", "lot", "auctions"})
+    # PageOutcome carried two fields no engine ever set (a scroll trace and
+    # seller facts), and the sidecar logic around them could never fire.
+    for eng in ("playwright", "selenium", "puppeteer"):
+        src = open(os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                eng + "_scraper.py"), encoding="utf-8").read()
+        ok &= check("%s: no never-assigned scroll/shop outcome fields" % eng,
+                    "shop_facts" not in src and "o.scroll" not in src)
+
     advice = page_flow.block_advice(BLOCKED_403, headless=True, has_pool=False)
     ok &= check("the block advice names the real cause (headless), not the proxy",
                 "HEADLESS" in advice and "--headful" in advice)
@@ -860,8 +951,10 @@ def test_output_contract():
     # relative timer.
     ok &= check("the listing-only columns are declared too",
                 {"time_left_text", "bid_status_text"} <= set(names))
-    ok &= check("both modes are one row per sku",
-                set(UNIQUE_BY_SKU_MODES) == {"listing", "product"})
+    # This once pinned {"listing", "product"}: a mode this repo does not have,
+    # so the test defended the defect that made diff_runs refuse every lot run.
+    ok &= check("listing and lot are the modes that are one row per sku",
+                set(UNIQUE_BY_SKU_MODES) == {"listing", "lot"})
 
     ok &= check("the exit codes are the family's",
                 (EXIT_BLOCKED, EXIT_NO_PRODUCTS, EXIT_PARTIAL) == (3, 4, 6))
@@ -1007,15 +1100,14 @@ def test_finish_run():
 def test_diff():
     group("diff_runs")
     ok = True
-    # `price_source` on this site is "dom" for a listing row and
-    # "meta+apollo" for a detail row — there is no structured price on a
-    # listing page to confirm against — so the source-change case uses those
-    # two values rather than the sibling repos' jsonld pair.
+    # `price_source` on this site is "next_data+dom" for a listing row and
+    # "next_data" for a lot page, so the source-change case uses those two
+    # values.
     old = [{"sku": "1", "price": 10.0, "price_source": "dom"},
            {"sku": "2", "price": 20.0, "price_source": "dom"},
            {"sku": "3", "price": 30.0, "price_source": "dom"}]
     new = [{"sku": "1", "price": 11.0, "price_source": "dom"},
-           {"sku": "3", "price": 30.5, "price_source": "meta+apollo"},
+           {"sku": "3", "price": 30.5, "price_source": "next_data"},
            {"sku": "4", "price": 40.0, "price_source": "dom"}]
     d = diff_products(old, new)
     ok &= check("a real price move is reported as changed",
@@ -1068,8 +1160,8 @@ def test_diff():
           "price_source": "next_data+dom"}])
     ok &= check("a new bid on an open lot is still a change",
                 len(outbid["changed"]) == 1)
-    # The sibling repo's from-price columns are NOT tracked, because they do
-    # not exist here: a card prints one amount, not a range.
+    # From-price columns are NOT tracked, because they do not exist here: a
+    # card prints one amount, not a range.
     ok &= check("no from-price columns are tracked (this site has none)",
                 not {"price_is_from", "price_max"} & set(tracked))
     ok &= check("...and Product does not declare them either",
@@ -1451,7 +1543,7 @@ def test_fingerprint_client_reads_env():
     import fingerprint_client as fpc
 
     # THE DEFECT THIS PINS, found the first time --fingerprint was run live
-    # here and confirmed present in five sibling repos: `--key` defaulted to
+    # here: `--key` defaulted to
     # `os.environ.get("TWOCAPTCHA_KEY")` alone. So a key put in `.env` —
     # which is exactly what §3, the README and .env.example instruct — worked
     # for every engine and failed HERE with "No API key". A documented
@@ -1519,8 +1611,7 @@ def test_fingerprint_application():
     # Dutch fingerprint. An English-speaking visitor in the Netherlands is
     # possible, but it is not what this fingerprint describes, and a locale
     # that contradicts the rest of the identity is the mismatch again. This
-    # was one of the six defects a sibling repo inherited from copied core
-    # and never ran (§16).
+    # was a defect in the copied fingerprint core that nothing had run (§16).
     ok &= check("the locale is the fingerprint's own, not en-<country>",
                 kw.get("locale") == "nl-NL")
     ok &= check("the timezone is carried, so the browser cannot contradict it",
@@ -1894,8 +1985,7 @@ def test_captcha():
     # ...while the DETECTORS stay broad, which is the family's standing
     # policy: which challenge a visitor meets depends on the exit country and
     # on what the address has been doing.
-    # The marker set is deliberately SHORT on this site, and shorter than
-    # the sibling repos'. None of these has ever been observed here —
+    # The marker set is deliberately SHORT on this site, None of these has ever been observed here —
     # a refused request is not a page at all — so every entry is a guess
     # about a bot manager that might be switched on between deploys, and a
     # long list of guesses is not better than a short one.
@@ -2004,8 +2094,7 @@ def test_env_config():
     # which carries no credential and is a working default.
     ok &= check("the example's default URL is usable as-is",
                 _placeholder_reads_unset(
-                    "https://www.catawiki.com/en/c/333-watches"
-                    "kopi-bubuk") is False)
+                    "https://www.catawiki.com/en/c/333-watches") is False)
 
     with tempfile.TemporaryDirectory() as d:
         path = os.path.join(d, ".env")
@@ -2246,9 +2335,7 @@ def test_engines(skips):
         # three scrolls to the document's own bottom added zero cards and left
         # the page height unchanged on all three page kinds, so an engine that
         # grew a loop back would be buying latency for nothing -- and would
-        # disagree with its twins about what a settled page is. A sibling repo
-        # cannot see one product without the scroll, which is exactly why this
-        # was measured here instead of ported.
+        # disagree with its twins about what a settled page is.
         ok &= check("%s has no scroll loop of its own" % name,
                     "scroll_until_settled" not in src
                     and "scroll_to_bottom" not in src)