Commit 0733eb41267 for woocommerce

commit 0733eb41267d80d40f7dbaa8fa1cdd59305f0737
Author: AnnaMag <AnnaMag@users.noreply.github.com>
Date:   Mon Nov 16 13:02:59 2026 +0100

    Agent readiness: more 11.4 store checks, regression guards, and served GTIN and brand checks (#70577)

    * Add agent readiness checks and regression guards

    Add the 11.4 checks for what a store serves to agents, including
    served GTIN and brand, and guards that a stock store still passes.



    * Fix false failures in the new store checks

    Prices such as R$ 10,00 and WooCommerce's own rounded JSON-LD
    price were flagged. A 401 was treated as a sign-in wall, archive
    pages failed the canonical check, and the UCP check never called
    catalog search.



    * Fix store check tests that miss their path

    The review markup fixtures were named Mug, so the check never
    looked at the product. A failed home page still stops post_json.



    * Accept a JSON 400 from UCP catalog search

    An empty search is refused. That 400 means the route is up.

diff --git a/plugins/woocommerce/changelog/add-agent-readiness-regression-guards b/plugins/woocommerce/changelog/add-agent-readiness-regression-guards
new file mode 100644
index 00000000000..ed0e228d9ad
--- /dev/null
+++ b/plugins/woocommerce/changelog/add-agent-readiness-regression-guards
@@ -0,0 +1,3 @@
+Significance: patch
+Type: dev
+Comment: Agent readiness: more store checks, GTIN and brand checks on the served page, and declared items behind the agent readiness flag; nothing ships to merchants.
diff --git a/plugins/woocommerce/src/Internal/AgentReadiness/AgentReadiness.php b/plugins/woocommerce/src/Internal/AgentReadiness/AgentReadiness.php
index 73e270dfdfd..4a4ab6627f8 100644
--- a/plugins/woocommerce/src/Internal/AgentReadiness/AgentReadiness.php
+++ b/plugins/woocommerce/src/Internal/AgentReadiness/AgentReadiness.php
@@ -350,7 +350,7 @@ class AgentReadiness {
 	 *
 	 * @param array<string, mixed>|null                                                                                                               $report Stored report.
 	 * @param array<int, array{id:string,ok:bool|null,blocks:string,level:string,name:string,label:string,why:string,fix:string,fix_url:string}>|null $live   Store conditions already read, or null to read them.
-	 * @return array<int, array{id:string,ok:bool|null,blocks:string,group?:string,level:string,name:string,label:string,why:string,fix:string,fix_url:string,conflict?:bool,pending?:bool}>
+	 * @return array<int, array{id:string,ok:bool|null,blocks:string,group?:string,level:string,name:string,label:string,why:string,fix:string,fix_url:string,conflict?:bool,pending?:bool,seen_at?:string}>
 	 */
 	public function get_store_checks( ?array $report, ?array $live = null ): array {
 		$checks   = $live ?? $this->store_conditions->all();
@@ -372,6 +372,7 @@ class AgentReadiness {
 				'fix_url'  => (string) ( $check['fix_url'] ?? '' ),
 				'conflict' => ! empty( $check['conflict'] ),
 				'pending'  => ! empty( $check['pending'] ),
+				'seen_at'  => (string) ( $check['seen_at'] ?? '' ),
 			);
 		}
 		return $checks;
diff --git a/plugins/woocommerce/src/Internal/AgentReadiness/AgenticCommerceSettingsPage.php b/plugins/woocommerce/src/Internal/AgentReadiness/AgenticCommerceSettingsPage.php
index 407df4f205a..15e37e1dec7 100644
--- a/plugins/woocommerce/src/Internal/AgentReadiness/AgenticCommerceSettingsPage.php
+++ b/plugins/woocommerce/src/Internal/AgentReadiness/AgenticCommerceSettingsPage.php
@@ -316,7 +316,11 @@ class AgenticCommerceSettingsPage extends \WC_Settings_Page {
 	 * @param array<string, mixed> $report Stored report.
 	 */
 	private function render_product_checks( array $report ): void {
-		$channels = is_array( $report['channels'] ?? null ) ? $report['channels'] : array();
+		$channels = array_filter( is_array( $report['channels'] ?? null ) ? $report['channels'] : array(), 'is_array' );
+		$channels = array_map(
+			static fn( array $channel ): array => $channel + array_fill_keys( array( 'url', 'name', 'spec', 'listable', 'not_listable', 'with_gaps', 'complete' ), '' ),
+			$channels
+		);
 		$failing  = array_filter(
 			is_array( $report['checks'] ?? null ) ? $report['checks'] : array(),
 			static fn( $check ): bool => is_array( $check ) && (int) ( $check['count'] ?? 0 ) > 0
@@ -642,8 +646,8 @@ class AgenticCommerceSettingsPage extends \WC_Settings_Page {
 	/**
 	 * A table of store checks.
 	 *
-	 * @param array<int, array{id:string,ok:bool|null,blocks:string,level:string,name:string,why:string,fix:string,fix_url:string,conflict?:bool,pending?:bool}> $checks   Checks.
-	 * @param bool|null                                                                                                                                          $launched Whether the store is launched.
+	 * @param array<int, array{id:string,ok:bool|null,blocks:string,level:string,name:string,why:string,fix:string,fix_url:string,conflict?:bool,pending?:bool,seen_at?:string}> $checks   Checks.
+	 * @param bool|null                                                                                                                                                          $launched Whether the store is launched.
 	 */
 	private function render_check_rows( array $checks, ?bool $launched ): void {
 		if ( array() === $checks ) {
@@ -675,6 +679,9 @@ class AgenticCommerceSettingsPage extends \WC_Settings_Page {
 							<?php echo esc_html( $check['name'] ); ?>
 							<?php if ( false === $check['ok'] ) : ?>
 								<br /><span class="description"><?php echo esc_html( trim( ( $conflict ? __( 'Something on your store may be replacing this. If you just changed it, a page cache may show the old page for a while.', 'woocommerce' ) . ' ' : '' ) . $check['why'] . ' ' . self::blocks_text( $check['blocks'] ) ) ); ?></span>
+								<?php if ( $conflict && ! empty( $check['seen_at'] ) ) : ?>
+									<br /><span class="description"><?php esc_html_e( 'Seen on:', 'woocommerce' ); ?> <a href="<?php echo esc_url( $check['seen_at'] ); ?>"><?php echo esc_html( $check['seen_at'] ); ?></a></span>
+								<?php endif; ?>
 							<?php endif; ?>
 						</td>
 						<td>
@@ -722,9 +729,9 @@ class AgenticCommerceSettingsPage extends \WC_Settings_Page {
 	 * affect the switch, so they sit apart from the setup checks in Status. Run check is
 	 * at the top, and the product checks sit under "Do they understand your products?".
 	 *
-	 * @param array<int, array{id:string,ok:bool|null,blocks:string,group?:string,level:string,name:string,why:string,fix:string,fix_url:string,conflict?:bool,pending?:bool}> $checks   Scanned checks.
-	 * @param bool                                                                                                                                                             $launched Whether the store is launched.
-	 * @param array<string, mixed>|null                                                                                                                                        $report   Stored report, or null before the first scan.
+	 * @param array<int, array{id:string,ok:bool|null,blocks:string,group?:string,level:string,name:string,why:string,fix:string,fix_url:string,conflict?:bool,pending?:bool,seen_at?:string}> $checks   Scanned checks.
+	 * @param bool                                                                                                                                                                             $launched Whether the store is launched.
+	 * @param array<string, mixed>|null                                                                                                                                                        $report   Stored report, or null before the first scan.
 	 */
 	private function render_readiness( array $checks, bool $launched, ?array $report ): void {
 		$results = array_column( $checks, 'ok', 'id' );
diff --git a/plugins/woocommerce/src/Internal/AgentReadiness/DeclaredToAgents.php b/plugins/woocommerce/src/Internal/AgentReadiness/DeclaredToAgents.php
index c7f6748c508..68a05344445 100644
--- a/plugins/woocommerce/src/Internal/AgentReadiness/DeclaredToAgents.php
+++ b/plugins/woocommerce/src/Internal/AgentReadiness/DeclaredToAgents.php
@@ -38,27 +38,23 @@ class DeclaredToAgents {
 				'found' => self::document_served( $responses, $document[1], $document[2] ),
 			);
 		}
-		$robots = $responses->get( StoreOutputChecks::host_root( '/robots.txt' ) );
-		$home   = $responses->home_page();
-		$page   = $responses->product_page();
-		$feed   = $responses->get( '/feed/' );
-		$lines  = array(
-			'feed-present'             => array( __( 'RSS or Atom feed', 'woocommerce' ), null === $feed || StoreOutputChecks::blocked( $feed['status'] ) ? null : 200 === $feed['status'] && 1 === preg_match( '/<(rss|feed)[\s>]/i', $feed['body'] ) ),
-			'sameas-links'             => array( __( 'sameAs links in structured data', 'woocommerce' ), self::json_ld_has( $home, 'sameAs' ) ),
-			'site-search-action'       => array( __( 'SearchAction for on-site search', 'woocommerce' ), self::has_search_action( $home ) ),
-			'webmcp-forms-schema'      => array( __( 'Forms that expose declarative WebMCP', 'woocommerce' ), self::page_has_tag( array( $home, $page ), array( 'FORM' ), static fn( \WP_HTML_Tag_Processor $tag ): bool => null !== $tag->get_attribute( 'toolname' ) && null !== $tag->get_attribute( 'tooldescription' ) ) ),
-			'sitemap-lastmod'          => array( __( 'Sitemap has lastmod dates', 'woocommerce' ), self::sitemap_has_lastmod( $responses, $robots ) ),
-			'markdown-pages'           => array( __( 'Markdown version of pages (Accept: text/markdown)', 'woocommerce' ), self::is_markdown( self::markdown_answer( $responses ) ) ),
-			'markdown-alternate-link'  => array( __( 'Pages link to their Markdown version', 'woocommerce' ), self::page_has_tag( array( $home, $page ), array( 'LINK' ), static fn( \WP_HTML_Tag_Processor $tag ): bool => in_array( 'alternate', self::tokens( $tag->get_attribute( 'rel' ) ), true ) && 0 === stripos( trim( (string) $tag->get_attribute( 'type' ) ), 'text/markdown' ) ) ),
-			'markdown-frontmatter'     => array( __( 'Markdown versions start with frontmatter', 'woocommerce' ), self::has_frontmatter( self::markdown_answer( $responses ) ) ),
-			'product-review-schema'    => array( __( 'Product review markup', 'woocommerce' ), null === $page ? null : self::product_has_reviews( $page['body'] ) ),
-			'code-block-language'      => array( __( 'Code blocks tagged with their language', 'woocommerce' ), self::page_has_tag( array( $home, $page ), array( 'PRE', 'CODE' ), static fn( \WP_HTML_Tag_Processor $tag ): bool => 1 === preg_match( '/(?:^|\s)(?:language|lang)-[\w+#-]+/i', (string) $tag->get_attribute( 'class' ) ) ) ),
-			'editorial-metadata'       => array( __( 'Author and publish date', 'woocommerce' ), self::has_editorial_metadata( array( $home, $page ) ) ),
-			'site-search-autocomplete' => array( __( 'On-site search with autocomplete', 'woocommerce' ), self::page_has_tag( array( $home ), array( 'INPUT' ), array( self::class, 'is_autocomplete_search' ) ) ),
-			'mcp-server-card'          => array( __( 'MCP server card', 'woocommerce' ), self::either( self::document_served( $responses, '/.well-known/mcp/server-card.json', array( self::class, 'is_mcp_server_card' ) ), self::document_served( $responses, '/.well-known/mcp.json', array( self::class, 'is_mcp_server_card' ) ) ) ),
+		$home  = $responses->home_page();
+		$page  = $responses->product_page();
+		$lines = array(
+			'sameas-links'                => array( __( 'sameAs links in structured data', 'woocommerce' ), self::json_ld_has( $home, 'sameAs' ) ),
+			'site-search-action'          => array( __( 'SearchAction for on-site search', 'woocommerce' ), self::has_search_action( $home ) ),
+			'webmcp-forms-schema'         => array( __( 'Forms that expose declarative WebMCP', 'woocommerce' ), self::page_has_tag( array( $home, $page ), array( 'FORM' ), static fn( \WP_HTML_Tag_Processor $tag ): bool => null !== $tag->get_attribute( 'toolname' ) && null !== $tag->get_attribute( 'tooldescription' ) ) ),
+			'markdown-pages'              => array( __( 'Markdown version of pages (Accept: text/markdown)', 'woocommerce' ), self::is_markdown( self::markdown_answer( $responses ) ) ),
+			'markdown-alternate-link'     => array( __( 'Pages link to their Markdown version', 'woocommerce' ), self::page_has_tag( array( $home, $page ), array( 'LINK' ), static fn( \WP_HTML_Tag_Processor $tag ): bool => in_array( 'alternate', self::tokens( $tag->get_attribute( 'rel' ) ), true ) && 0 === stripos( trim( (string) $tag->get_attribute( 'type' ) ), 'text/markdown' ) ) ),
+			'markdown-frontmatter'        => array( __( 'Markdown versions start with frontmatter', 'woocommerce' ), self::has_frontmatter( self::markdown_answer( $responses ) ) ),
+			'link-header-agent-resources' => array( __( 'Link header pointing to the API catalog or llms.txt', 'woocommerce' ), self::links_agent_resources( $home ) ),
+			'code-block-language'         => array( __( 'Code blocks tagged with their language', 'woocommerce' ), self::page_has_tag( array( $home, $page ), array( 'PRE', 'CODE' ), static fn( \WP_HTML_Tag_Processor $tag ): bool => 1 === preg_match( '/(?:^|\s)(?:language|lang)-[\w+#-]+/i', (string) $tag->get_attribute( 'class' ) ) ) ),
+			'editorial-metadata'          => array( __( 'Author and publish date', 'woocommerce' ), self::has_editorial_metadata( array( $home, $page ) ) ),
+			'site-search-autocomplete'    => array( __( 'On-site search with autocomplete', 'woocommerce' ), self::page_has_tag( array( $home ), array( 'INPUT' ), array( self::class, 'is_autocomplete_search' ) ) ),
+			'mcp-server-card'             => array( __( 'MCP server card', 'woocommerce' ), self::either( self::document_served( $responses, '/.well-known/mcp/server-card.json', array( self::class, 'is_mcp_server_card' ) ), self::document_served( $responses, '/.well-known/mcp.json', array( self::class, 'is_mcp_server_card' ) ) ) ),
 			// Not read yet: DNS-AID needs a DNS lookup, and a feed product sync is set up outside the store's pages.
-			'dns-aid'                  => array( __( 'DNS for AI Discovery (DNS-AID)', 'woocommerce' ), null ),
-			'product-feed-automation'  => array( __( 'Automated product feed', 'woocommerce' ), null ),
+			'dns-aid'                     => array( __( 'DNS for AI Discovery (DNS-AID)', 'woocommerce' ), null ),
+			'product-feed-automation'     => array( __( 'Automated product feed', 'woocommerce' ), null ),
 		);
 		foreach ( $lines as $id => $line ) {
 			$items[] = array(
@@ -82,6 +78,7 @@ class DeclaredToAgents {
 			'agents-md'    => array( __( 'AGENTS.md', 'woocommerce' ), '/AGENTS.md' ),
 			'security-txt' => array( __( 'security.txt', 'woocommerce' ), '/.well-known/security.txt' ),
 			'auth-md'      => array( __( 'auth.md agent sign-in instructions', 'woocommerce' ), '/auth.md' ),
+			'llms-full'    => array( __( 'llms-full.txt', 'woocommerce' ), '/llms-full.txt' ),
 		);
 	}

@@ -94,6 +91,7 @@ class DeclaredToAgents {
 	private function documents(): array {
 		$has = static fn( string ...$keys ): callable => static fn( array $document ): bool => array() === array_diff( $keys, array_keys( array_filter( $document ) ) );
 		return array(
+			'api-catalog'              => array( __( 'API catalog', 'woocommerce' ), '/.well-known/api-catalog', $has( 'linkset' ) ),
 			'tdmrep'                   => array( __( 'TDMRep text-and-data-mining reservation', 'woocommerce' ), '/.well-known/tdmrep.json', static fn( array $document ): bool => isset( $document[0]['location'] ) ),
 			'a2a-agent-card'           => array( __( 'A2A Agent Card', 'woocommerce' ), '/.well-known/agent-card.json', $has( 'name', 'skills' ) ),
 			'agent-skills-index'       => array( __( 'Agent Skills index', 'woocommerce' ), '/.well-known/agent-skills/index.json', $has( 'skills' ) ),
@@ -226,36 +224,6 @@ class DeclaredToAgents {
 		return $named && ( ! empty( $document['endpoint'] ) || ! empty( $document['url'] ) || ! empty( $document['remotes'] ) || ! empty( $document['transport'] ) );
 	}

-	/**
-	 * Whether the store's first sitemap has lastmod dates, in a sitemap index or in the first sitemap it lists.
-	 *
-	 * @param StoreResponses                                                  $responses Store responses.
-	 * @param array{status:int,body:string,headers:array<string,string>}|null $robots    The robots.txt response.
-	 */
-	private static function sitemap_has_lastmod( StoreResponses $responses, ?array $robots ): ?bool {
-		// Without robots.txt the store's own sitemap list isn't known.
-		$unknown = null === $robots || ( $robots['status'] >= 400 && 404 !== $robots['status'] );
-		foreach ( StoreOutputChecks::sitemap_urls( 200 === ( $robots['status'] ?? 0 ) ? $robots['body'] : '' ) as $url ) {
-			$response = $responses->get( $url );
-			if ( null === $response || StoreOutputChecks::blocked( $response['status'] ) ) {
-				$unknown = true;
-				continue;
-			}
-			if ( 200 !== $response['status'] || 1 !== preg_match( '/<(urlset|sitemapindex)[\s>]/i', $response['body'] ) ) {
-				continue;
-			}
-			if ( false !== stripos( $response['body'], '<lastmod' ) ) {
-				return true;
-			}
-			if ( 1 !== preg_match( '#<sitemapindex.*?<loc>\s*(.+?)\s*</loc>#is', $response['body'], $first ) ) {
-				return false;
-			}
-			$child = $responses->get( html_entity_decode( $first[1], ENT_QUOTES | ENT_XML1 ) );
-			return null === $child || StoreOutputChecks::blocked( $child['status'] ) ? null : 200 === $child['status'] && false !== stripos( $child['body'], '<lastmod' );
-		}
-		return $unknown ? null : false;
-	}
-
 	/**
 	 * The product page, or the home page without a product, asked for as Markdown.
 	 *
@@ -369,16 +337,46 @@ class DeclaredToAgents {
 	}

 	/**
-	 * Whether the product page's JSON-LD has reviews or a rating.
+	 * Whether the page's Link header points to the API catalog or llms.txt.
 	 *
-	 * @param string $html Product page HTML.
+	 * @param array{status:int,body:string,headers:array<string,string>}|null $page Page, null when it didn't load.
 	 */
-	private static function product_has_reviews( string $html ): bool {
-		foreach ( JsonLd::items( $html, 'Product', 'ProductGroup' ) as $item ) {
-			if ( ! empty( $item['review'] ) || ! empty( $item['aggregateRating'] ) ) {
+	private static function links_agent_resources( ?array $page ): ?bool {
+		if ( null === $page ) {
+			return null;
+		}
+		// Each value is <target> followed by ;-separated parameters; rel holds space-separated tokens.
+		preg_match_all( '/<([^>]*)>((?:[^,"<]|"[^"]*")*)/', $page['headers']['link'] ?? '', $values, PREG_SET_ORDER );
+		foreach ( $values as $value ) {
+			if ( self::is_host_root_llms_txt( trim( $value[1] ) ) ) {
 				return true;
 			}
+			// Parameters are read left to right, so a quoted value is taken whole, ; and rel= in it included.
+			preg_match_all( '/;\s*([^=;\s]+)\s*(?:=\s*(?:"([^"]*)"|([^;]*)))?/', $value[2], $params, PREG_SET_ORDER );
+			foreach ( $params as $param ) {
+				if ( 'rel' === strtolower( $param[1] ) && in_array( 'api-catalog', self::tokens( ( $param[2] ?? '' ) . ' ' . ( $param[3] ?? '' ) ), true ) ) {
+					return true;
+				}
+			}
 		}
 		return false;
 	}
+
+	/**
+	 * Whether a Link target is this store's `/llms.txt` at the host root, where the file is read.
+	 * A relative target is resolved there, including when WordPress lives in a subdirectory.
+	 * A link to another site's llms.txt does not count.
+	 *
+	 * @param string $target Target from the Link header.
+	 */
+	private static function is_host_root_llms_txt( string $target ): bool {
+		while ( str_starts_with( $target, './' ) ) {
+			$target = substr( $target, 2 );
+		}
+		$absolute = \WP_Http::make_absolute_url( $target, StoreOutputChecks::host_root( '/' ) );
+		$path     = wp_parse_url( $absolute, PHP_URL_PATH );
+		$host     = wp_parse_url( $absolute, PHP_URL_HOST );
+		$store    = wp_parse_url( home_url(), PHP_URL_HOST );
+		return '/llms.txt' === $path && is_string( $host ) && is_string( $store ) && 0 === strcasecmp( $host, $store );
+	}
 }
diff --git a/plugins/woocommerce/src/Internal/AgentReadiness/JsonLd.php b/plugins/woocommerce/src/Internal/AgentReadiness/JsonLd.php
index 06bce81a94b..a200ebce80f 100644
--- a/plugins/woocommerce/src/Internal/AgentReadiness/JsonLd.php
+++ b/plugins/woocommerce/src/Internal/AgentReadiness/JsonLd.php
@@ -22,7 +22,7 @@ class JsonLd {
 	 * @return array<int, array<string, mixed>>
 	 */
 	public static function items( string $html, string ...$types ): array {
-		if ( ! preg_match_all( '#<script\b[^>]*\btype\s*=\s*["\']?application/ld\+json["\']?[^>]*>(.*?)</script>#is', $html, $blocks ) ) {
+		if ( ! preg_match_all( '#<script\b(?:[^>"\']|"[^"]*"|\'[^\']*\')*?(?<![\w-])type\s*=\s*["\']?application/ld\+json["\']?(?:[^>"\']|"[^"]*"|\'[^\']*\')*>(.*?)</script>#is', $html, $blocks ) ) {
 			return array();
 		}
 		$items = array();
diff --git a/plugins/woocommerce/src/Internal/AgentReadiness/README.md b/plugins/woocommerce/src/Internal/AgentReadiness/README.md
index 836dc5522d4..9d97e663efc 100644
--- a/plugins/woocommerce/src/Internal/AgentReadiness/README.md
+++ b/plugins/woocommerce/src/Internal/AgentReadiness/README.md
@@ -4,7 +4,7 @@ Checks published simple and variable products against the product data specs of

 ## What the checks read

-The checks read product data and store settings, because most gaps are empty fields only the merchant can fill, and a check can name the product and field. When data is filled in but a store output (UCP catalog, product structured data) doesn't send it, that is a bug fixed in that output's code, not a check. Where a plugin can add or replace what core builds (robots.txt, sitemaps, `llms.txt`, page markup), store checks read what the store returns instead (`StoreOutputChecks`), and pass when any source provides the item. What the store can't see from inside, such as crawler blocks at a CDN, is left to an outside scan of the store's public pages.
+The checks read product data and store settings, because most gaps are empty fields only the merchant can fill, and a check can name the product and field. When data is filled in but a store output (UCP catalog, product structured data) doesn't send it, that is a bug fixed in that output's code, not a check. Where a plugin can add or replace what core builds (robots.txt, sitemaps, `llms.txt`, page markup), store checks read what the store returns instead (`StoreOutputChecks`), and pass when any source provides the item. A crawler block at a CDN or firewall shows only when the store's request to itself goes through it; an outside scan of the store's public pages covers the rest, along with page speed and layout shift.

 ## Channels

@@ -69,22 +69,46 @@ Store-wide conditions (`StoreConditions`) are reported first because they affect
 | `llms_txt_valid` | It starts with a `# Name` heading. |
 | `llms_txt_links_resolve` | The first five links in it to the store's own pages open (no 4xx). Links to other sites, or with a query string, aren't loaded. |
 | `open_graph_tags` | The home and product page have `og:title` and `og:image`. |
-| `meta_description` | The home and product page have a meta description. |
-| `canonical_url` | The product page has a canonical link. |
+| `meta_description` | The home, product, shop and category page have a meta description, of those that loaded. |
+| `canonical_url` | The product page has a canonical link. Shop and category archives are not checked: WordPress does not print one there, and WooCommerce does not add one yet. |
 | `organization_schema` | The home page's JSON-LD has an Organization, or a type stores use for themselves such as OnlineStore. |
 | `ai_snippet_directives` | No robots meta tag or `X-Robots-Tag` header on the home or product page sets `nosnippet` or a `max-snippet` limit. |
 | `content_in_raw_html` | The product page's text, without scripts or comments, has the product's name and its price as a whole amount. |
+| `no_noindex_directives` | No robots meta tag or `X-Robots-Tag` header on the home or product page sets `noindex`, `none`, `noai` or `noimageai`. |
+| `pages_public` | The home, shop and product page don't redirect to `wp-login.php` or My account. A 401 or 403 is "couldn't check": a firewall can refuse the store's request to itself. |
+| `sitemap_lastmod` | A sitemap listed in robots.txt, or `/wp-sitemap.xml`, `/sitemap_index.xml` or `/sitemap.xml`, has `lastmod` dates. An index that does not has its child sitemaps on this host opened, at any depth, up to five child requests. |
+| `rss_feed` | The home page links to an RSS or Atom feed. |
+| `viewport_meta` | The home page has a viewport meta tag. |
+| `html_lang_and_charset` | The home page's `html` element has `lang`, and a meta tag or the `Content-Type` header gives a charset. |
+| `images_have_alt` | Every image on the home and product page has an `alt` attribute (empty counts); images hidden from assistive technology, 1×1 tracking pixels and `noscript` fallbacks are skipped. |
+| `single_h1` | The product page has exactly one `h1`. |
+| `schema_matches_product` | A Product item names the product and, for a product with one price, one of its own items offers that price with or without tax, at any tax rate of its tax class since the page was served to one location; a failure shows as a likely conflict. |
+| `product_gtin_jsonld` | The product's JSON-LD or its offers give a valid GTIN (`gtin`, `gtin8`, `gtin12`, `gtin13` or `gtin14`), from any source. Fails as a likely conflict only when the product's own GTIN is valid but the page gives none or an invalid one. Skipped when the product doesn't need one, or its own GTIN is missing or invalid: `missing_gtin` and `invalid_gtin` report those. |
+| `product_brand_jsonld` | The product's JSON-LD gives a brand, from any source. Fails as a likely conflict only when the product has a WooCommerce brand (`product_brand`), the only brand WooCommerce prints. A brand kept in an attribute or another plugin's taxonomy isn't printed by WooCommerce, so the check is skipped then and `missing_brand` reports the stored value. |
+| `product_review_markup` | The newest visible published product with reviews (of the five newest with reviews) has `aggregateRating` or `review` in its JSON-LD. Passes when reviews are off or no product has any. |
+| `policy_pages_linked` | The home page links to the privacy policy and refund and returns pages the store set. Skipped when neither is set. |
 | `ucp_profile` | With UCP on: `/.well-known/ucp` is served and names a REST endpoint. |
-| `ucp_endpoints_live` | With UCP on: a catalog search POSTed to that endpoint, or WooCommerce's when there is no profile, answers with a product list. |
+| `ucp_endpoints_live` | With UCP on: a POST to `{endpoint}/catalog/search`, the route agents call, answers with JSON. A 200 or a 400 both count: an empty body is refused because a query or a filter is required. The endpoint is the one the profile names, or WooCommerce's when there is no profile. |
 | `ucp_profile_version` | With UCP on: the served profile declares the UCP version WooCommerce implements (`UcpUtils::VERSION`). A different version usually means another plugin serves its own profile. |
 | `ucp_checkout` | With UCP on: the served profile declares `dev.ucp.shopping.checkout`. Pending (WOOAI-1435). |
 | `product_return_policy_schema` | A product offer in the product page's JSON-LD has `hasMerchantReturnPolicy`. Pending (WOOPRD-3912). |
-| `product_shipping_schema` | A product offer has `shippingDetails`. Pending (WOOPRD-3908). |
-| `product_buy_action_schema` | The product or an offer has a `BuyAction` in `potentialAction`. Pending (WOOPRD-3918). |
+| `product_shipping_schema` | A product offer has `shippingDetails`. "Couldn't check" for a product that doesn't ship. Pending (WOOPRD-3908). |
+| `product_buy_action_schema` | The product or an offer has a `BuyAction` in `potentialAction`. "Couldn't check" for a variable product without one: WooCommerce links only a chosen variation to checkout (WOOPRD-3946, after the ProductGroup work in WOOPRD-3907). Pending (WOOPRD-3918). |

-A check listed in `StoreOutputChecks::PENDING` tests output WooCommerce doesn't build yet. It doesn't run: it's reported with `ok` null and `pending` true, so it reads as coming soon, not as failed or couldn't check. Remove its entry when that output ships; the issues that build the output are in the comment on the list.
+A likely conflict names the page where it was seen (`seen_at`), not a plugin: a list of plugins goes stale, and several plugins can change the same output (WOOAI-1618).

-robots.txt is loaded from the host root, only to find the sitemaps it lists. Its crawler rules aren't checked: a host or CDN can rewrite the file or block crawlers without it, and the store's request to itself skips both, so they wait for an outside view of the store (WOOPRD-3953). The sitemap check is "couldn't check" when robots.txt could not be read, or a candidate sitemap could not be loaded or answered other than 200, 404 or 410, and no fetched sitemap names products. A category sitemap does not count. When an index does not name products, its child sitemaps on this host are checked, nested indexes included (Jetpack serves one past 1,000 URLs), up to five child requests in all. Sitemap lines on another host, or written as `//host/path`, are skipped and do not use up the five listed slots. Checks on the home and product page read the ones that loaded. The home page loads first; when it can't be reached, the scan makes no more requests, so a store that can't reach itself waits for one timeout. The product checks load one product page: among the five newest published simple or variable products in the shop catalog, the newest with a price and no password, or the newest without a password when none of them has a price. With no such product, or when its page doesn't answer 200, they are "couldn't check".
+The checks judge what the store returns, whoever provides it. Some things they can't see, by design (WOOAI-1618):
+
+- What a plugin sends a channel directly. Google for WooCommerce sends its own GTIN and brand to Google, so the page can pass while Google gets another value (WOOAI-1595).
+- Output that depends on the shopper. The scan is a logged-out visitor with the store's default currency and prices; a currency switcher or wholesale pricing shows other shoppers other values.
+- Values added in the browser. The page is read as the server sends it, so JSON-LD a script adds after load is missed.
+- Every product. Output checks read one product page; the stored-data checks run on every product.
+
+A check listed in `StoreOutputChecks::PENDING` tests output WooCommerce doesn't build yet. It doesn't run: it's reported with `ok` null and `pending` true, so it reads as coming soon, not as failed or couldn't check. Remove its entry when that output ships.
+
+robots.txt is loaded from the host root, only to find the sitemaps it lists. Its crawler rules aren't checked: a host or CDN can rewrite the file or block crawlers without it, and the store's request to itself skips both, so they wait for an outside view of the store (WOOPRD-3953). The sitemap check is "couldn't check" when robots.txt could not be read, or a candidate sitemap could not be loaded or answered other than 200, 404 or 410, and no fetched sitemap names products. A category sitemap does not count. When an index does not name products, its child sitemaps on this host are checked, nested indexes included (Jetpack serves one past 1,000 URLs), up to five child requests in all. Sitemap lines on another host, or written as `//host/path`, are skipped and do not use up the five listed slots. Checks on the home and product page read the ones that loaded. The product structured data checks also read the variants a ProductGroup lists in `hasVariant`, where a variable product's offers sit once it is printed as a ProductGroup (WOOPRD-3907). The category page is one of the sampled product's categories, or the largest category when it has none. The home page loads first; when it can't be reached, the scan makes no more requests, so a store that can't reach itself waits for one timeout. The product checks load one product page: among the five newest published simple or variable products in the shop catalog, the newest with a price and no password, or the newest without a password when none of them has a price. With no such product, or when its page doesn't answer 200, they are "couldn't check".
+
+The checks from `no_noindex_directives` down pass on a stock store today. They stay as regression guards, so a merchant hears when a host, theme or plugin breaks one.

 ## Failures per product

diff --git a/plugins/woocommerce/src/Internal/AgentReadiness/ReportAbility.php b/plugins/woocommerce/src/Internal/AgentReadiness/ReportAbility.php
index e7125f641c7..a56929a1c13 100644
--- a/plugins/woocommerce/src/Internal/AgentReadiness/ReportAbility.php
+++ b/plugins/woocommerce/src/Internal/AgentReadiness/ReportAbility.php
@@ -120,6 +120,11 @@ class ReportAbility implements AbilityDefinition {
 										'type'        => array( 'boolean', 'null' ),
 										'description' => __( 'True when the store passes, false when it fails, null when the check could not run.', 'woocommerce' ),
 									),
+									'group'    => array(
+										'type'        => 'string',
+										'enum'        => array( 'access', 'find', 'understand', 'buy', '' ),
+										'description' => __( 'The question the check answers: access (can agents get in), find (can they find the store), understand (do they understand the products) or buy (can they buy). Empty in a report from before checks had a group.', 'woocommerce' ),
+									),
 									'blocks'   => array(
 										'type'        => 'string',
 										'description' => __( 'What a failure stops: listing (every product everywhere), discovery (harder for agents to find and read the store), ucp (agents using UCP) or checkout (agent orders).', 'woocommerce' ),
@@ -141,6 +146,10 @@ class ReportAbility implements AbilityDefinition {
 										'type'        => 'boolean',
 										'description' => __( 'On output checks: true for a check of output a coming WooCommerce update builds; it does not run yet.', 'woocommerce' ),
 									),
+									'seen_at'  => array(
+										'type'        => 'string',
+										'description' => __( 'On a likely conflict: the address where it was seen.', 'woocommerce' ),
+									),
 								),
 							),
 						),
diff --git a/plugins/woocommerce/src/Internal/AgentReadiness/StoreOutputChecks.php b/plugins/woocommerce/src/Internal/AgentReadiness/StoreOutputChecks.php
index 077470c1d31..bd420bb2ed6 100644
--- a/plugins/woocommerce/src/Internal/AgentReadiness/StoreOutputChecks.php
+++ b/plugins/woocommerce/src/Internal/AgentReadiness/StoreOutputChecks.php
@@ -3,6 +3,7 @@ declare( strict_types = 1 );

 namespace Automattic\WooCommerce\Internal\AgentReadiness;

+use Automattic\WooCommerce\Enums\ProductStatus;
 use Automattic\WooCommerce\Internal\ComingSoon\ComingSoonHelper;
 use Automattic\WooCommerce\StoreApi\Utilities\Ucp\Utils as UcpUtils;

@@ -51,7 +52,10 @@ class StoreOutputChecks {
 	/**
 	 * Run every check. Each URL is requested at most once.
 	 *
-	 * @return array<int, array{id:string,ok:bool|null,blocks:string,group:string,level:string,name:string,label:string,why:string,fix:string,fix_url:string,conflict:bool,pending:bool}>
+	 * A likely conflict also names the address where it was seen. It doesn't name a plugin: any list of
+	 * plugins goes stale, and several can change the same output.
+	 *
+	 * @return array<int, array{id:string,ok:bool|null,blocks:string,group:string,level:string,name:string,label:string,why:string,fix:string,fix_url:string,conflict:bool,pending:bool,seen_at:string}>
 	 */
 	public function all(): array {
 		return $this->all_for( $this->responses() );
@@ -63,7 +67,7 @@ class StoreOutputChecks {
 	 * @since 11.4.0
 	 *
 	 * @param StoreResponses $responses Responses of the scan.
-	 * @return array<int, array{id:string,ok:bool|null,blocks:string,group:string,level:string,name:string,label:string,why:string,fix:string,fix_url:string,conflict:bool,pending:bool}>
+	 * @return array<int, array{id:string,ok:bool|null,blocks:string,group:string,level:string,name:string,label:string,why:string,fix:string,fix_url:string,conflict:bool,pending:bool,seen_at:string}>
 	 */
 	public function all_for( StoreResponses $responses ): array {
 		// The home page first: when it can't be reached, no other request is made.
@@ -81,6 +85,7 @@ class StoreOutputChecks {
 					array( 'source' => 'agent-readiness' )
 				);
 			}
+			$conflict  = false === $ok && ! empty( $check['conflict'] );
 			$results[] = array(
 				'id'       => $check['id'],
 				'ok'       => $ok,
@@ -92,8 +97,9 @@ class StoreOutputChecks {
 				'why'      => $check['why'],
 				'fix'      => $check['fix'],
 				'fix_url'  => $check['fix_url'],
-				'conflict' => false === $ok && ! empty( $check['conflict'] ),
+				'conflict' => $conflict,
 				'pending'  => $pending,
+				'seen_at'  => $conflict ? self::seen_at( (string) ( $check['seen_at'] ?? '' ), $responses ) : '',
 			);
 		}
 		return $results;
@@ -131,7 +137,7 @@ class StoreOutputChecks {
 	/**
 	 * The checks, each with a test that returns true, false, or null for couldn't check.
 	 *
-	 * @return array<int, array{id:string,test:callable(StoreResponses):(bool|null),blocks:string,group:string,name:string,label:string,why:string,fix:string,fix_url:string,conflict?:bool}>
+	 * @return array<int, array{id:string,test:callable(StoreResponses):(bool|null),blocks:string,group:string,name:string,label:string,why:string,fix:string,fix_url:string,conflict?:bool,seen_at?:string}>
 	 */
 	protected function checks(): array {
 		$checks = array(
@@ -156,6 +162,7 @@ class StoreOutputChecks {
 				'why'     => __( 'Shopping crawlers and search engines read the product\'s JSON-LD to get its name, price and stock without guessing from the page.', 'woocommerce' ),
 				'fix'     => __( 'WooCommerce adds it to the product page. Check whether your theme or an SEO plugin turns WooCommerce\'s structured data off.', 'woocommerce' ),
 				'fix_url' => '',
+				'seen_at' => 'product',
 			),
 			array(
 				'id'       => 'product_jsonld_from_core',
@@ -164,10 +171,11 @@ class StoreOutputChecks {
 				'blocks'   => 'discovery',
 				'name'     => __( 'Product structured data comes from WooCommerce, once', 'woocommerce' ),
 				'label'    => __( 'Something replaces or repeats WooCommerce\'s product structured data', 'woocommerce' ),
-				'why'      => __( 'Seen on a recent product page. Agents may read values that differ from your product, or two versions of it.', 'woocommerce' ),
+				'why'      => __( 'Agents may read values that differ from your product, or two versions of it.', 'woocommerce' ),
 				'fix'      => __( 'Usually an SEO plugin or your theme. Check its schema settings; if you chose this, you can ignore it.', 'woocommerce' ),
 				'fix_url'  => '',
 				'conflict' => true,
+				'seen_at'  => 'product',
 			),
 			array(
 				'id'      => 'product_jsonld_required_fields',
@@ -232,18 +240,18 @@ class StoreOutputChecks {
 				'name'    => __( 'Pages have Open Graph tags', 'woocommerce' ),
 				'label'   => __( 'Pages are missing Open Graph tags', 'woocommerce' ),
 				'why'     => __( 'Agents and social apps use og:title and og:image to show a page as a card with a picture.', 'woocommerce' ),
-				'fix'     => __( 'Turn on Open Graph or social tags in your SEO plugin, or in Jetpack.', 'woocommerce' ),
+				'fix'     => __( 'WooCommerce adds them to product pages. For your home page, turn on Open Graph or social tags in your SEO plugin, or in Jetpack.', 'woocommerce' ),
 				'fix_url' => '',
 			),
 			array(
 				'id'      => 'meta_description',
 				'group'   => 'find',
-				'test'    => fn( StoreResponses $responses ): ?bool => $this->on_pages( $responses, static fn( string $html ): bool => PageMarkup::has_meta( $html, 'name', 'description' ) ),
+				'test'    => fn( StoreResponses $responses ): ?bool => self::on_loaded( array( $responses->home_page(), $responses->product_page(), $responses->shop_page(), $responses->category_page() ), static fn( string $html ): bool => PageMarkup::has_meta( $html, 'name', 'description' ) ),
 				'blocks'  => 'discovery',
-				'name'    => __( 'Pages have a meta description', 'woocommerce' ),
-				'label'   => __( 'Pages are missing a meta description', 'woocommerce' ),
+				'name'    => __( 'Home, product, shop and category pages have a meta description', 'woocommerce' ),
+				'label'   => __( 'Some store pages are missing a meta description', 'woocommerce' ),
 				'why'     => __( 'Search and AI answers often quote the meta description to say what a page is about.', 'woocommerce' ),
-				'fix'     => __( 'Add a meta description for your home page and products in your SEO plugin.', 'woocommerce' ),
+				'fix'     => __( 'Add meta descriptions for your home page, shop, categories and products in your SEO plugin.', 'woocommerce' ),
 				'fix_url' => '',
 			),
 			array(
@@ -254,7 +262,7 @@ class StoreOutputChecks {
 				'name'    => __( 'Product pages name their canonical URL', 'woocommerce' ),
 				'label'   => __( 'Product pages don\'t name a canonical URL', 'woocommerce' ),
 				'why'     => __( 'A product can be reached by several URLs; the canonical link tells agents which one to show.', 'woocommerce' ),
-				'fix'     => __( 'WordPress adds it to product pages. Check whether your theme or a plugin removes it.', 'woocommerce' ),
+				'fix'     => __( 'WordPress adds a canonical link to product pages. If it\'s missing, a plugin or your theme is removing it.', 'woocommerce' ),
 				'fix_url' => '',
 			),
 			array(
@@ -290,6 +298,155 @@ class StoreOutputChecks {
 				'fix'     => __( 'Use a theme or page builder that prints the product name and price in the page, or ask its developer.', 'woocommerce' ),
 				'fix_url' => '',
 			),
+			array(
+				'id'      => 'no_noindex_directives',
+				'group'   => 'access',
+				'test'    => fn( StoreResponses $responses ): ?bool => $this->on_pages( $responses, static fn( string $html, array $headers ): bool => ! self::restricts_indexing( self::robots_rules( $html, $headers ) ) ),
+				'blocks'  => 'listing',
+				'name'    => __( 'Pages let search and AI crawlers index them', 'woocommerce' ),
+				'label'   => __( 'Pages ask search and AI crawlers not to index them', 'woocommerce' ),
+				'why'     => __( 'A noindex, noai or noimageai robots rule keeps your pages and products out of search and AI answers.', 'woocommerce' ),
+				'fix'     => __( 'Remove noindex, noai and noimageai from the robots settings in your SEO plugin, or ask your host about an X-Robots-Tag header.', 'woocommerce' ),
+				'fix_url' => '',
+			),
+			array(
+				'id'      => 'pages_public',
+				'group'   => 'access',
+				'test'    => fn( StoreResponses $responses ): ?bool => $this->pages_public( $responses ),
+				'blocks'  => 'listing',
+				'name'    => __( 'Store pages open without signing in', 'woocommerce' ),
+				'label'   => __( 'Store pages ask visitors to sign in', 'woocommerce' ),
+				'why'     => __( 'Agents don\'t sign in, so they can\'t read your home, shop or product pages.', 'woocommerce' ),
+				'fix'     => __( 'Check the membership, private store or maintenance plugin that asks visitors to sign in.', 'woocommerce' ),
+				'fix_url' => '',
+			),
+			array(
+				'id'      => 'sitemap_lastmod',
+				'group'   => 'find',
+				'test'    => fn( StoreResponses $responses ): ?bool => $this->sitemap_has_lastmod( $responses ),
+				'blocks'  => 'discovery',
+				'name'    => __( 'Sitemap says when pages changed', 'woocommerce' ),
+				'label'   => __( 'Sitemap has no lastmod dates', 'woocommerce' ),
+				'why'     => __( 'Crawlers use lastmod dates to come back for changed prices and stock first.', 'woocommerce' ),
+				'fix'     => __( 'Turn on lastmod dates in your SEO plugin\'s sitemap settings.', 'woocommerce' ),
+				'fix_url' => '',
+			),
+			array(
+				'id'      => 'rss_feed',
+				'group'   => 'find',
+				'test'    => fn( StoreResponses $responses ): ?bool => $this->on_home_page( $responses, static fn( string $html ): bool => self::has_feed_link( $html ) ),
+				'blocks'  => 'discovery',
+				'name'    => __( 'Home page links to a feed', 'woocommerce' ),
+				'label'   => __( 'Home page doesn\'t link to a feed', 'woocommerce' ),
+				'why'     => __( 'Some agents follow your RSS or Atom feed to see what is new.', 'woocommerce' ),
+				'fix'     => __( 'Check whether your theme or a plugin removes the feed links WordPress adds.', 'woocommerce' ),
+				'fix_url' => '',
+			),
+			array(
+				'id'      => 'viewport_meta',
+				'group'   => 'understand',
+				'test'    => fn( StoreResponses $responses ): ?bool => $this->on_home_page( $responses, static fn( string $html ): bool => PageMarkup::has_meta( $html, 'name', 'viewport' ) ),
+				'blocks'  => 'discovery',
+				'name'    => __( 'Home page sets a viewport', 'woocommerce' ),
+				'label'   => __( 'Home page has no viewport tag', 'woocommerce' ),
+				'why'     => __( 'Browser agents load your pages at a phone or desktop size; without a viewport tag the layout can break.', 'woocommerce' ),
+				'fix'     => __( 'Use a theme that adds a viewport meta tag, or ask its developer.', 'woocommerce' ),
+				'fix_url' => '',
+			),
+			array(
+				'id'      => 'html_lang_and_charset',
+				'group'   => 'understand',
+				'test'    => fn( StoreResponses $responses ): ?bool => self::has_lang_and_charset( $responses->home_page() ),
+				'blocks'  => 'discovery',
+				'name'    => __( 'Home page declares its language and encoding', 'woocommerce' ),
+				'label'   => __( 'Home page doesn\'t declare its language or encoding', 'woocommerce' ),
+				'why'     => __( 'Agents use the language to answer shoppers in theirs, and the encoding to read names and prices without garbled text.', 'woocommerce' ),
+				'fix'     => __( 'Use a theme that sets the lang attribute and a charset meta tag, or ask its developer.', 'woocommerce' ),
+				'fix_url' => '',
+			),
+			array(
+				'id'      => 'images_have_alt',
+				'group'   => 'understand',
+				'test'    => fn( StoreResponses $responses ): ?bool => $this->on_pages( $responses, static fn( string $html ): bool => self::images_have_alt( $html ) ),
+				'blocks'  => 'discovery',
+				'name'    => __( 'Images have alt text', 'woocommerce' ),
+				'label'   => __( 'Some images have no alt text', 'woocommerce' ),
+				'why'     => __( 'Agents that can\'t see images rely on alt text to know what a picture shows.', 'woocommerce' ),
+				'fix'     => __( 'Add alt text to images in the media library and to product images. Images your theme adds need its developer.', 'woocommerce' ),
+				'fix_url' => admin_url( 'upload.php' ),
+			),
+			array(
+				'id'      => 'single_h1',
+				'group'   => 'understand',
+				'test'    => fn( StoreResponses $responses ): ?bool => $this->on_product_page( $responses, static fn( string $html ): bool => 1 === self::count_tags( $html, 'h1' ) ),
+				'blocks'  => 'discovery',
+				'name'    => __( 'Product pages have one main heading', 'woocommerce' ),
+				'label'   => __( 'Product pages have no main heading, or more than one', 'woocommerce' ),
+				'why'     => __( 'Agents read the H1 heading as the name of the product the page is about.', 'woocommerce' ),
+				'fix'     => __( 'Check the product template of your theme or page builder: the product title should be the only H1.', 'woocommerce' ),
+				'fix_url' => '',
+			),
+			array(
+				'id'       => 'schema_matches_product',
+				'group'    => 'understand',
+				'test'     => fn( StoreResponses $responses ): ?bool => $this->with_products( $responses, static fn( array $products ): ?bool => array() === $products ? null : self::schema_matches( $products, $responses->product() ) ),
+				'blocks'   => 'discovery',
+				'name'     => __( 'Product structured data matches the product', 'woocommerce' ),
+				'label'    => __( 'Product structured data shows a different name or price', 'woocommerce' ),
+				'why'      => __( 'Agents quote the structured data, so shoppers may see a name or price your store doesn\'t charge.', 'woocommerce' ),
+				'fix'      => __( 'Usually an SEO plugin or your theme. Check its schema settings, or clear your page cache.', 'woocommerce' ),
+				'fix_url'  => '',
+				'conflict' => true,
+				'seen_at'  => 'product',
+			),
+			array(
+				'id'       => 'product_gtin_jsonld',
+				'group'    => 'understand',
+				'test'     => fn( StoreResponses $responses ): ?bool => $this->with_products( $responses, static fn( array $products ): ?bool => array() === $products ? null : self::served_gtin_ok( $products, $responses->product() ) ),
+				'blocks'   => 'listing',
+				'name'     => __( 'Product structured data has a valid GTIN', 'woocommerce' ),
+				'label'    => __( 'Product structured data has no valid GTIN', 'woocommerce' ),
+				'why'      => __( 'Agents match products by GTIN, and the product page gives none or an invalid one.', 'woocommerce' ),
+				'fix'      => __( 'WooCommerce adds the GTIN from the product\'s GTIN field. If it\'s filled in, an SEO plugin or your theme is likely replacing it: check its schema settings.', 'woocommerce' ),
+				'fix_url'  => '',
+				'conflict' => true,
+				'seen_at'  => 'product',
+			),
+			array(
+				'id'       => 'product_brand_jsonld',
+				'group'    => 'understand',
+				'test'     => fn( StoreResponses $responses ): ?bool => $this->with_products( $responses, static fn( array $products ): ?bool => array() === $products ? null : self::served_brand_ok( $products, $responses->product() ) ),
+				'blocks'   => 'listing',
+				'name'     => __( 'Product structured data has a brand', 'woocommerce' ),
+				'label'    => __( 'Product structured data has no brand', 'woocommerce' ),
+				'why'      => __( 'ChatGPT needs a brand to list a product. Your product has one, but the page gives agents none.', 'woocommerce' ),
+				'fix'      => __( 'WooCommerce adds the product\'s brand. Usually an SEO plugin or your theme replaces it: check its schema settings.', 'woocommerce' ),
+				'fix_url'  => '',
+				'conflict' => true,
+				'seen_at'  => 'product',
+			),
+			array(
+				'id'      => 'product_review_markup',
+				'group'   => 'understand',
+				'test'    => fn( StoreResponses $responses ): ?bool => $this->reviews_marked_up( $responses ),
+				'blocks'  => 'discovery',
+				'name'    => __( 'Product reviews are in structured data', 'woocommerce' ),
+				'label'   => __( 'Product reviews are missing from structured data', 'woocommerce' ),
+				'why'     => __( 'Agents compare ratings between stores; reviews only on the page are easy to miss.', 'woocommerce' ),
+				'fix'     => __( 'WooCommerce adds the rating to product structured data. Check whether your theme or an SEO plugin removes it.', 'woocommerce' ),
+				'fix_url' => '',
+			),
+			array(
+				'id'      => 'policy_pages_linked',
+				'group'   => 'buy',
+				'test'    => fn( StoreResponses $responses ): ?bool => self::links_policy_pages( $responses->home_page() ),
+				'blocks'  => 'checkout',
+				'name'    => __( 'Home page links to your privacy and returns pages', 'woocommerce' ),
+				'label'   => __( 'Home page doesn\'t link to your privacy or returns page', 'woocommerce' ),
+				'why'     => __( 'Agents look for policy links on the home page before they send a shopper to your checkout.', 'woocommerce' ),
+				'fix'     => __( 'Add your privacy policy and refund and returns pages to the footer or a menu.', 'woocommerce' ),
+				'fix_url' => '',
+			),
 			array(
 				'id'      => 'product_return_policy_schema',
 				'group'   => 'buy',
@@ -304,7 +461,7 @@ class StoreOutputChecks {
 			array(
 				'id'      => 'product_shipping_schema',
 				'group'   => 'buy',
-				'test'    => fn( StoreResponses $responses ): ?bool => $this->with_products( $responses, static fn( array $products ): bool => self::offer_has( $products, 'shippingDetails' ) ),
+				'test'    => fn( StoreResponses $responses ): ?bool => $this->with_products( $responses, static fn( array $products ): ?bool => self::ships( $responses ) ? self::offer_has( $products, 'shippingDetails' ) : null ),
 				'blocks'  => 'listing',
 				'name'    => __( 'Product structured data gives shipping details', 'woocommerce' ),
 				'label'   => __( 'Product structured data has no shipping details', 'woocommerce' ),
@@ -315,7 +472,7 @@ class StoreOutputChecks {
 			array(
 				'id'      => 'product_buy_action_schema',
 				'group'   => 'buy',
-				'test'    => fn( StoreResponses $responses ): ?bool => $this->with_products( $responses, static fn( array $products ): bool => self::has_buy_action( $products ) ),
+				'test'    => fn( StoreResponses $responses ): ?bool => $this->with_products( $responses, static fn( array $products ): ?bool => self::has_buy_action( $products, $responses->product() ) ),
 				'blocks'  => 'listing',
 				'name'    => __( 'Product structured data says how to buy', 'woocommerce' ),
 				'label'   => __( 'Product structured data has no buy action', 'woocommerce' ),
@@ -324,6 +481,21 @@ class StoreOutputChecks {
 				'fix_url' => '',
 			),
 		);
+		if ( self::core_open_graph_on() ) {
+			$checks[] = array(
+				'id'       => 'open_graph_from_core',
+				'group'    => 'find',
+				'test'     => fn( StoreResponses $responses ): ?bool => $this->on_product_page( $responses, static fn( string $html ): bool => self::has_open_graph( $html, 'og:title' ) ),
+				'blocks'   => 'discovery',
+				'name'     => __( 'Product pages keep WooCommerce\'s Open Graph tags', 'woocommerce' ),
+				'label'    => __( 'Product pages are missing WooCommerce\'s Open Graph tags', 'woocommerce' ),
+				'why'      => __( 'WooCommerce adds og:title and og:image to product pages, so agents and social apps can show the product as a card.', 'woocommerce' ),
+				'fix'      => __( 'Usually an SEO, social or caching plugin, or your theme, rewrites the page. Check their Open Graph settings.', 'woocommerce' ),
+				'fix_url'  => '',
+				'conflict' => true,
+				'seen_at'  => 'product',
+			);
+		}
 		if ( ! UcpUtils::is_enabled() ) {
 			return $checks;
 		}
@@ -339,6 +511,7 @@ class StoreOutputChecks {
 			'fix'      => __( 'Save Settings > Permalinks to refresh the rules. If it still fails, ask your host whether caching or a firewall blocks /.well-known/ucp.', 'woocommerce' ),
 			'fix_url'  => admin_url( 'options-permalink.php' ),
 			'conflict' => true,
+			'seen_at'  => home_url( '/.well-known/ucp' ),
 		);
 		$checks[] = array(
 			'id'       => 'ucp_profile_version',
@@ -352,15 +525,16 @@ class StoreOutputChecks {
 			'fix'      => __( 'Look for another plugin that adds UCP or agentic commerce, and turn off its UCP profile.', 'woocommerce' ),
 			'fix_url'  => admin_url( 'plugins.php' ),
 			'conflict' => true,
+			'seen_at'  => home_url( '/.well-known/ucp' ),
 		);
 		$checks[] = array(
 			'id'      => 'ucp_endpoints_live',
 			'group'   => 'access',
-			'test'    => fn( StoreResponses $responses ): ?bool => self::catalog_search_answers( $responses ),
+			'test'    => fn( StoreResponses $responses ): ?bool => self::ucp_endpoint_answers( $responses ),
 			'blocks'  => 'ucp',
-			'name'    => __( 'UCP catalog search answers', 'woocommerce' ),
-			'label'   => __( 'UCP catalog search doesn\'t answer', 'woocommerce' ),
-			'why'     => __( 'Agents search your catalog through UCP; when it fails they can\'t find your products.', 'woocommerce' ),
+			'name'    => __( 'UCP endpoint answers', 'woocommerce' ),
+			'label'   => __( 'UCP endpoint is blocked or doesn\'t answer', 'woocommerce' ),
+			'why'     => __( 'Agents search your catalog and build carts through this endpoint; when it\'s blocked they can\'t find your products.', 'woocommerce' ),
 			'fix'     => __( 'Ask your host or security plugin to allow requests to the WordPress REST API under /wp-json/wc/ucp/.', 'woocommerce' ),
 			'fix_url' => '',
 		);
@@ -388,6 +562,28 @@ class StoreOutputChecks {
 		return ( $home['scheme'] ?? 'http' ) . '://' . ( $home['host'] ?? '' ) . ( isset( $home['port'] ) ? ':' . $home['port'] : '' ) . $path;
 	}

+	/**
+	 * The address a conflict was seen at: 'product' for the product page the scan read, else the address itself.
+	 *
+	 * @param string         $seen_at   'product' or an address.
+	 * @param StoreResponses $responses Store responses.
+	 */
+	private static function seen_at( string $seen_at, StoreResponses $responses ): string {
+		if ( 'product' !== $seen_at ) {
+			return $seen_at;
+		}
+		$product = $responses->product();
+		return null === $product ? '' : (string) $product->get_permalink();
+	}
+
+	/**
+	 * Whether WooCommerce adds Open Graph tags to product pages. It needs WordPress's template output buffer.
+	 */
+	private static function core_open_graph_on(): bool {
+		// phpcs:ignore WooCommerce.Commenting.CommentHooks.MissingHookComment -- Documented in StructuredData\OpenGraph.
+		return function_exists( 'wp_start_template_enhancement_output_buffer' ) && (bool) apply_filters( 'woocommerce_enable_open_graph', true );
+	}
+
 	/**
 	 * The robots.txt crawlers get. '' when the store answered that there is none.
 	 * Null when it could not be read: the request failed, or the body is a page.
@@ -414,7 +610,7 @@ class StoreOutputChecks {
 	 * @param string $robots The robots.txt text.
 	 * @return string[]
 	 */
-	public static function sitemap_urls( string $robots ): array {
+	private static function sitemap_urls( string $robots ): array {
 		$listed   = array_slice(
 			array_values( array_filter( ( new RobotsTxt( $robots ) )->sitemaps(), array( StoreResponses::class, 'is_store_url' ) ) ),
 			0,
@@ -436,6 +632,18 @@ class StoreOutputChecks {
 	 * @param StoreResponses $responses Store responses.
 	 */
 	private function sitemap_lists_products( StoreResponses $responses ): ?bool {
+		return $this->sitemap_matches( $responses, array( self::class, 'names_products' ) );
+	}
+
+	/**
+	 * Whether a test passes for a sitemap the store serves. Child sitemaps on this host are opened
+	 * at any depth, up to five child requests. A child on another host is skipped. Null when
+	 * robots.txt or one of those sitemaps could not be loaded and the test never passed.
+	 *
+	 * @param StoreResponses $responses Store responses.
+	 * @param callable       $test      Test, given a sitemap body.
+	 */
+	private function sitemap_matches( StoreResponses $responses, callable $test ): ?bool {
 		$robots  = $this->robots_txt( $responses );
 		$queue   = array_values( array_unique( array_map( array( self::class, 'absolute_url' ), self::sitemap_urls( (string) $robots ) ) ) );
 		$seen    = array_fill_keys( $queue, true );
@@ -446,7 +654,7 @@ class StoreOutputChecks {
 			if ( null === $body ) {
 				continue;
 			}
-			if ( self::names_products( $body ) ) {
+			if ( $test( $body ) ) {
 				return true;
 			}
 			foreach ( self::index_child_urls( $body ) as $child ) {
@@ -509,7 +717,7 @@ class StoreOutputChecks {
 			if ( false === $end ) {
 				break;
 			}
-			$url = trim( str_replace( array( '<![CDATA[', ']]>' ), '', substr( $xml, $start, $end - $start ) ) );
+			$url = html_entity_decode( trim( str_replace( array( '<![CDATA[', ']]>' ), '', substr( $xml, $start, $end - $start ) ) ), ENT_QUOTES | ENT_XML1 );
 			if ( '' !== $url ) {
 				$urls[] = $url;
 			}
@@ -545,6 +753,7 @@ class StoreOutputChecks {
 	 * @param array<int, array<string, mixed>> $products Product items.
 	 */
 	private static function has_required_fields( array $products ): bool {
+		$products = self::with_variants( $products );
 		foreach ( array( 'name', 'image', 'offers' ) as $field ) {
 			if ( array() === array_filter( $products, static fn( array $product ): bool => ! empty( $product[ $field ] ) ) ) {
 				return false;
@@ -565,8 +774,7 @@ class StoreOutputChecks {
 		if ( null === $product ) {
 			return null;
 		}
-		$schemeless = static fn( string $url ): string => (string) preg_replace( '#^https?:#i', '', html_entity_decode( $url, ENT_QUOTES | ENT_HTML5, 'UTF-8' ) );
-		return 1 === count( $products ) && $schemeless( $product->get_permalink() . '#product' ) === $schemeless( (string) ( $products[0]['@id'] ?? '' ) );
+		return 1 === count( $products ) && self::comparable_url( $product->get_permalink() . '#product' ) === self::comparable_url( (string) ( $products[0]['@id'] ?? '' ) );
 	}

 	/**
@@ -576,16 +784,7 @@ class StoreOutputChecks {
 	 * @param array<int, array<string, mixed>> $products Product items.
 	 */
 	private static function has_priced_offer( array $products ): bool {
-		$offers = array();
-		foreach ( $products as $product ) {
-			array_push( $offers, ...self::as_list( $product['offers'] ?? null ) );
-		}
-		// An AggregateOffer can list its offers; read them too, one level down.
-		$nested = array();
-		foreach ( $offers as $offer ) {
-			array_push( $nested, ...self::as_list( $offer['offers'] ?? null ) );
-		}
-		foreach ( array_merge( $offers, $nested ) as $offer ) {
+		foreach ( self::offers( $products ) as $offer ) {
 			$prices = array_merge( array( $offer['price'] ?? null, $offer['lowPrice'] ?? null ), array_column( self::as_list( $offer['priceSpecification'] ?? null ), 'price' ) );
 			if ( ! empty( $offer['availability'] ) && array() !== array_filter( $prices, array( self::class, 'has_price_amount' ) ) ) {
 				return true;
@@ -617,14 +816,34 @@ class StoreOutputChecks {
 	}

 	/**
-	 * Whether a test passes on the home page and the product page, of those that loaded.
-	 * Null when neither loaded.
+	 * Whether a test passes on the home page and the product page. A failure on a page that loaded
+	 * counts even when the other page didn't. Null when a page that had to load didn't, and nothing failed.
+	 * A store with no product to check is judged on its home page.
 	 *
 	 * @param StoreResponses $responses Store responses.
 	 * @param callable       $test      Test, given the HTML and the response headers.
 	 */
 	private function on_pages( StoreResponses $responses, callable $test ): ?bool {
-		$pages = array_filter( array( $responses->home_page(), $responses->product_page() ) );
+		$home    = $responses->home_page();
+		$product = $responses->product_page();
+		$result  = self::on_loaded( array( $home, $product ), $test );
+		if ( false === $result ) {
+			return false;
+		}
+		if ( null === $home || ( null === $product && null !== $responses->product() ) ) {
+			return null;
+		}
+		return $result;
+	}
+
+	/**
+	 * Whether a test passes on each page that loaded. Null when none loaded.
+	 *
+	 * @param array<int, array{status:int,body:string,headers:array<string,string>}|null> $pages Pages, null for one that didn't load.
+	 * @param callable                                                                    $test  Test, given the HTML and the response headers.
+	 */
+	private static function on_loaded( array $pages, callable $test ): ?bool {
+		$pages = array_filter( $pages );
 		if ( array() === $pages ) {
 			return null;
 		}
@@ -685,6 +904,7 @@ class StoreOutputChecks {
 			return $has;
 		}
 		// Links with a query string are skipped: one such as ?add-to-cart=12 would act on the store.
+		$links   = array_map( static fn( string $link ): string => explode( '#', $link, 2 )[0], $links );
 		$links   = array_filter( $links, static fn( string $link ): bool => $responses->is_store_url( $link ) && ! str_contains( $link, '?' ) );
 		$links   = array_slice( array_values( array_unique( $links ) ), 0, self::MAX_LLMS_TXT_LINKS );
 		$unknown = false;
@@ -722,9 +942,7 @@ class StoreOutputChecks {
 		return $this->on_pages(
 			$responses,
 			static function ( string $html, array $headers ): bool {
-				$rules   = PageMarkup::meta( $html, 'name', static fn( string $name ): bool => 'robots' === $name || str_ends_with( $name, 'bot' ) );
-				$rules[] = $headers['x-robots-tag'] ?? '';
-				$rules   = strtolower( implode( ', ', $rules ) );
+				$rules = self::robots_rules( $html, $headers );
 				if ( preg_match( '/(?<![\w-])nosnippet\b/', $rules ) ) {
 					return false;
 				}
@@ -753,7 +971,8 @@ class StoreOutputChecks {
 				}
 				// The amount as the store prints it, with its separators and filters, without the currency symbol.
 				$amount = PageMarkup::text( wc_price( wc_get_price_to_display( $product ) ) );
-				$amount = trim( (string) preg_replace( '/[^\d.,\x{00A0}\x{2009}\x{202F}\' ]/u', '', $amount ) );
+				$amount = (string) preg_replace( '/[^\d.,\x{00A0}\x{2009}\x{202F}\' ]/u', '', $amount );
+				$amount = (string) preg_replace( '/^\D+|\D+$/u', '', $amount );
 				if ( '' === $amount ) {
 					return false;
 				}
@@ -818,7 +1037,7 @@ class StoreOutputChecks {
 	 * @param string                           $property Offer property.
 	 */
 	private static function offer_has( array $products, string $property ): bool {
-		foreach ( $products as $product ) {
+		foreach ( self::with_variants( $products ) as $product ) {
 			foreach ( self::as_list( $product['offers'] ?? null ) as $offer ) {
 				if ( ! empty( $offer[ $property ] ) ) {
 					return true;
@@ -829,12 +1048,134 @@ class StoreOutputChecks {
 	}

 	/**
-	 * Whether a Product item or one of its offers has a BuyAction potentialAction.
+	 * Whether the scanned product needs shipping. A product that doesn't ship has no shipping details to give.
+	 *
+	 * @param StoreResponses $responses Store responses.
+	 */
+	private static function ships( StoreResponses $responses ): bool {
+		$product = $responses->product();
+		return null === $product || $product->needs_shipping();
+	}
+
+	/**
+	 * The Product items and the variants a ProductGroup lists in hasVariant. A variable product
+	 * printed as a ProductGroup carries its offers and buy actions on the variants, not the group.
 	 *
 	 * @param array<int, array<string, mixed>> $products Product items.
+	 * @return array<int, array<string, mixed>>
 	 */
-	private static function has_buy_action( array $products ): bool {
+	private static function with_variants( array $products ): array {
+		$items = $products;
 		foreach ( $products as $product ) {
+			array_push( $items, ...self::as_list( $product['hasVariant'] ?? null ) );
+		}
+		return $items;
+	}
+
+	/**
+	 * The product's own items, including a variant listed separately and linked with isVariantOf.
+	 *
+	 * @param array<int, array<string, mixed>> $products Product items.
+	 * @param \WC_Product                      $product  The product of the page.
+	 * @return array<int, array<string, mixed>>
+	 */
+	private static function identifier_items( array $products, \WC_Product $product ): array {
+		$own = self::own_items( $products, $product );
+		return self::with_variants( self::with_referenced_variants( array_merge( $own, self::variants_of( $own, $products ) ), $products ) );
+	}
+
+	/**
+	 * Replace a hasVariant entry that is only an @id with the Product node that id names.
+	 *
+	 * @param array<int, array<string, mixed>> $items     Selected items.
+	 * @param array<int, array<string, mixed>> $products Every Product item on the page.
+	 * @return array<int, array<string, mixed>>
+	 */
+	private static function with_referenced_variants( array $items, array $products ): array {
+		$by_id = array();
+		foreach ( $products as $item ) {
+			$id = $item['@id'] ?? null;
+			if ( is_string( $id ) && '' !== $id ) {
+				$by_id[ self::comparable_url( $id ) ] = $item;
+			}
+		}
+		foreach ( $items as $index => $item ) {
+			$variants = array();
+			foreach ( self::as_list( $item['hasVariant'] ?? null ) as $variant ) {
+				$id = $variant['@id'] ?? null;
+				if ( ! is_string( $id ) || '' === $id || array() !== array_diff( array_keys( $variant ), array( '@id', '@type' ) ) ) {
+					$variants[] = $variant;
+					continue;
+				}
+				$key        = self::comparable_url( $id );
+				$variants[] = $by_id[ $key ] ?? $variant;
+			}
+			if ( array() !== $variants ) {
+				$items[ $index ]['hasVariant'] = $variants;
+			}
+		}
+		return $items;
+	}
+
+	/**
+	 * Items that say they are a variant of one of the selected items.
+	 *
+	 * @param array<int, array<string, mixed>> $own      Selected items.
+	 * @param array<int, array<string, mixed>> $products Every Product item on the page.
+	 * @return array<int, array<string, mixed>>
+	 */
+	private static function variants_of( array $own, array $products ): array {
+		$ids = array();
+		foreach ( $own as $item ) {
+			if ( is_string( $item['@id'] ?? null ) && '' !== $item['@id'] ) {
+				$ids[ self::comparable_url( $item['@id'] ) ] = true;
+			}
+		}
+		if ( array() === $ids ) {
+			return array();
+		}
+		$linked = array();
+		foreach ( $products as $item ) {
+			foreach ( self::variant_of_ids( $item ) as $id ) {
+				if ( isset( $ids[ self::comparable_url( $id ) ] ) ) {
+					$linked[] = $item;
+					break;
+				}
+			}
+		}
+		return $linked;
+	}
+
+	/**
+	 * Identifiers an item's isVariantOf property gives.
+	 *
+	 * @param array<string, mixed> $item Product item.
+	 * @return array<int, string>
+	 */
+	private static function variant_of_ids( array $item ): array {
+		$of = $item['isVariantOf'] ?? null;
+		if ( is_string( $of ) ) {
+			return '' === $of ? array() : array( $of );
+		}
+		$ids = array();
+		foreach ( self::as_list( $of ) as $one ) {
+			if ( is_string( $one['@id'] ?? null ) && '' !== $one['@id'] ) {
+				$ids[] = $one['@id'];
+			}
+		}
+		return $ids;
+	}
+
+	/**
+	 * Whether a Product item, a variant or one of their offers has a BuyAction potentialAction.
+	 * Null for a variable product without one: WooCommerce doesn't link a variable product's
+	 * page to checkout, only a chosen variation.
+	 *
+	 * @param array<int, array<string, mixed>> $products Product items.
+	 * @param \WC_Product|null                 $scanned  The scanned product.
+	 */
+	private static function has_buy_action( array $products, ?\WC_Product $scanned = null ): ?bool {
+		foreach ( self::with_variants( $products ) as $product ) {
 			$items = array_merge( array( $product ), self::as_list( $product['offers'] ?? null ) );
 			foreach ( $items as $item ) {
 				foreach ( self::as_list( $item['potentialAction'] ?? null ) as $action ) {
@@ -844,33 +1185,68 @@ class StoreOutputChecks {
 				}
 			}
 		}
-		return false;
+		return null !== $scanned && $scanned->is_type( 'variable' ) ? null : false;
 	}

 	/**
-	 * Whether a catalog search through the UCP endpoint answers with a product list, using
-	 * the endpoint in the served profile, or WooCommerce's when the profile isn't served.
+	 * Whether catalog search, the route agents call, answers with JSON. The endpoint is the one the
+	 * served profile names, or WooCommerce's when the profile isn't served. The body is empty, so
+	 * WooCommerce refuses it with a JSON 400: a query or a filter is required. That 400 means the
+	 * route answered. A firewall or plugin that blocks the route blocks this request too.
 	 *
 	 * @param StoreResponses $responses Store responses.
 	 */
-	private static function catalog_search_answers( StoreResponses $responses ): ?bool {
-		$endpoint = self::ucp_endpoint( $responses ) ?? rest_url( 'wc/ucp/v1' );
-		$response = $responses->post_json(
-			untrailingslashit( $endpoint ) . '/catalog/search',
-			array(
-				'filters'    => array( 'price' => array( 'min' => 0 ) ),
-				'pagination' => array( 'limit' => 1 ),
-			)
-		);
+	private static function ucp_endpoint_answers( StoreResponses $responses ): ?bool {
+		$endpoint = untrailingslashit( self::ucp_endpoint( $responses ) ?? rest_url( 'wc/ucp/v1' ) );
+		$response = $responses->post_json( $endpoint . '/catalog/search', array() );
 		if ( null === $response || $response['status'] >= 500 ) {
 			return null;
 		}
-		$body = json_decode( $response['body'], true );
-		return 200 === $response['status'] && is_array( $body['products'] ?? null );
+		$json = is_array( json_decode( $response['body'], true ) );
+		return $json && ( 200 === $response['status'] || 400 === $response['status'] );
 	}

 	/**
-	 * Whether a JSON-LD price is a number, or text that contains one (`10.00`, `10,00`, `10.00 USD`).
+	 * The number in a JSON-LD price, or null when it isn't one. `10,00`, `99.00 USD`, `R$ 10,00` and `EUR 10,-` count.
+	 * A dot or slash in the currency, as in `S/.` or `kr.`, is not part of the number.
+	 *
+	 * @param mixed $value Price value.
+	 */
+	private static function price_amount( $value ): ?float {
+		if ( is_int( $value ) || is_float( $value ) ) {
+			return is_finite( $value ) ? (float) $value : null;
+		}
+		if ( ! is_string( $value ) ) {
+			return null;
+		}
+		$chars = self::amount_characters( $value );
+		if ( null === $chars ) {
+			return null;
+		}
+		// "10,-" and "10.-" are zero cents. The dash is not a minus sign.
+		$count = count( $chars );
+		if ( $count >= 2 && '-' === $chars[ $count - 1 ] && ( ',' === $chars[ $count - 2 ] || '.' === $chars[ $count - 2 ] ) ) {
+			array_pop( $chars );
+		}
+		$kept  = str_replace( "'", '', implode( '', $chars ) );
+		$comma = strrpos( $kept, ',' );
+		$dot   = strrpos( $kept, '.' );
+		if ( false !== $comma && false !== $dot ) {
+			$decimal   = $dot > $comma ? '.' : ',';
+			$thousands = '.' === $decimal ? ',' : '.';
+			$kept      = str_replace( $decimal, '.', str_replace( $thousands, '', $kept ) );
+		} elseif ( false !== $comma && strlen( $kept ) - $comma - 1 <= 2 ) {
+			$kept = str_replace( ',', '.', $kept );
+		} else {
+			$kept = str_replace( ',', '', $kept );
+		}
+		return is_numeric( $kept ) ? (float) $kept : null;
+	}
+
+	/**
+	 * Whether a JSON-LD price is a number, or text that is one with an optional currency symbol or code
+	 * (`10.00`, `10,00`, `$10`, `R$ 10,00`, `US$10`, `S/. 10`, `EUR 10,-`, `10,00 kr.`). A trailing
+	 * `,-` or `.-` means zero cents. Text such as `call 555` is not a price.
 	 *
 	 * @param mixed $value Price value.
 	 */
@@ -878,11 +1254,131 @@ class StoreOutputChecks {
 		if ( is_int( $value ) || is_float( $value ) ) {
 			return is_finite( $value );
 		}
-		if ( ! is_string( $value ) ) {
+		return is_string( $value ) && null !== self::amount_characters( $value );
+	}
+
+	/**
+	 * The amount characters of a price, currency removed from either end. Null when it isn't a price.
+	 *
+	 * @param string $value Price text.
+	 * @return array<int, string>|null
+	 */
+	private static function amount_characters( string $value ): ?array {
+		$chars = self::price_characters( $value );
+		if ( array() === $chars ) {
+			return null;
+		}
+		$chars = self::without_leading_currency( $chars );
+		$chars = array_reverse( self::without_leading_currency( array_reverse( $chars ) ) );
+		return self::characters_are_amount( $chars ) ? $chars : null;
+	}
+
+	/**
+	 * Characters of a price, without the spaces a store uses between the amount and the currency.
+	 *
+	 * @param string $value Price text.
+	 * @return array<int, string>
+	 */
+	private static function price_characters( string $value ): array {
+		$chars = mb_str_split( $value );
+		if ( ! is_array( $chars ) ) {
+			return array();
+		}
+		$kept = array();
+		foreach ( $chars as $char ) {
+			if ( ' ' === $char || "\t" === $char || "\n" === $char || "\r" === $char || "\u{00A0}" === $char || "\u{2009}" === $char || "\u{202F}" === $char ) {
+				continue;
+			}
+			$kept[] = $char;
+		}
+		return $kept;
+	}
+
+	/**
+	 * Drop one currency token from the front. A token is currency symbols and up to three letters,
+	 * plus the "." and "/" in abbreviations such as "kr." and "S/.". A longer word, such as "call", stays.
+	 *
+	 * @param array<int, string> $chars Characters.
+	 * @return array<int, string>
+	 */
+	private static function without_leading_currency( array $chars ): array {
+		$letters = 0;
+		$marked  = false;
+		$taken   = 0;
+		foreach ( $chars as $char ) {
+			$kind = self::price_char_kind( $char );
+			if ( 'letter' === $kind ) {
+				++$letters;
+				if ( $letters > 3 ) {
+					return $chars;
+				}
+				$marked = true;
+				++$taken;
+				continue;
+			}
+			if ( 'symbol' === $kind ) {
+				$marked = true;
+				++$taken;
+				continue;
+			}
+			// "." and "/" only belong to a token that also has a letter or a symbol, so "10.00" is left whole.
+			if ( 'mark' === $kind ) {
+				++$taken;
+				continue;
+			}
+			break;
+		}
+		return $marked ? array_slice( $chars, $taken ) : $chars;
+	}
+
+	/**
+	 * Whether a character is part of a currency token: a letter, a currency symbol, or "." or "/".
+	 *
+	 * Currency symbols have no other test than Unicode's Sc category.
+	 *
+	 * @param string $char One character.
+	 * @return string 'letter', 'symbol', 'mark' or ''.
+	 */
+	private static function price_char_kind( string $char ): string {
+		if ( '.' === $char || '/' === $char ) {
+			return 'mark';
+		}
+		if ( 1 === strlen( $char ) ) {
+			$byte = ord( $char );
+			if ( ( $byte >= 65 && $byte <= 90 ) || ( $byte >= 97 && $byte <= 122 ) ) {
+				return 'letter';
+			}
+			return '$' === $char ? 'symbol' : '';
+		}
+		return 1 === preg_match( '/^\p{Sc}$/u', $char ) ? 'symbol' : '';
+	}
+
+	/**
+	 * Whether the characters are a number, with "," or "." as a separator and an optional leading minus.
+	 * A trailing ",-" or ".-" means zero cents. A dash anywhere else is not an amount.
+	 *
+	 * @param array<int, string> $chars Characters.
+	 * @return bool
+	 */
+	private static function characters_are_amount( array $chars ): bool {
+		if ( array() !== $chars && '-' === $chars[0] ) {
+			array_shift( $chars );
+		}
+		$count = count( $chars );
+		if ( $count >= 2 && '-' === $chars[ $count - 1 ] && ( ',' === $chars[ $count - 2 ] || '.' === $chars[ $count - 2 ] ) ) {
+			array_pop( $chars );
+			array_pop( $chars );
+		}
+		if ( array() === $chars ) {
 			return false;
 		}
-		$normalized = str_replace( array( ',', ' ', "\u{00A0}" ), array( '.', '', '' ), $value );
-		return 1 === preg_match( '/-?\d+(?:\.\d+)?/', $normalized );
+		foreach ( $chars as $char ) {
+			if ( ! ctype_digit( $char ) && '.' !== $char && ',' !== $char && "'" !== $char ) {
+				return false;
+			}
+		}
+		$last = count( $chars ) - 1;
+		return ctype_digit( $chars[0] ) && ctype_digit( $chars[ $last ] );
 	}

 	/**
@@ -898,6 +1394,16 @@ class StoreOutputChecks {
 		return array_values( array_filter( wp_is_numeric_array( $value ) ? $value : array( $value ), 'is_array' ) );
 	}

+	/**
+	 * A JSON-LD property that may repeat, as a list of its values.
+	 *
+	 * @param mixed $value The property.
+	 * @return array<int, mixed>
+	 */
+	private static function values( $value ): array {
+		return is_array( $value ) && wp_is_numeric_array( $value ) ? $value : array( $value );
+	}
+
 	/**
 	 * Whether a sitemap index names a product sitemap (product-sitemap.xml,
 	 * wp-sitemap-posts-product-1.xml), or a urlset lists a product page. A category
@@ -916,4 +1422,542 @@ class StoreOutputChecks {
 		$base = trim( (string) strtok( (string) ( wc_get_permalink_structure()['product_base'] ?? '' ), '%' ), '/' );
 		return '' !== $base && 1 === preg_match( '#<loc>[^<]*/' . preg_quote( $base, '#' ) . '/[^<]+</loc>#i', $xml );
 	}
+
+	/**
+	 * The page's robots meta tags and X-Robots-Tag header in lowercase, rules for one crawler included.
+	 *
+	 * @param string                $html    Page HTML.
+	 * @param array<string, string> $headers Response headers.
+	 */
+	private static function robots_rules( string $html, array $headers ): string {
+		// googlebot-news contains "bot" without ending in it. "robots" does too.
+		$rules   = PageMarkup::meta( $html, 'name', static fn( string $name ): bool => str_contains( $name, 'bot' ) );
+		$rules[] = $headers['x-robots-tag'] ?? '';
+		return strtolower( implode( ', ', $rules ) );
+	}
+
+	/**
+	 * Whether robots rules ask crawlers not to index the page. `none` as the value of
+	 * max-image-preview, max-snippet, max-video-preview or unavailable_after does not.
+	 *
+	 * @param string $rules Lowercase robots rules.
+	 */
+	private static function restricts_indexing( string $rules ): bool {
+		$blocking = array( 'noindex', 'none', 'noai', 'noimageai' );
+		$valued   = array( 'max-image-preview', 'max-snippet', 'max-video-preview', 'unavailable_after' );
+		foreach ( explode( ',', $rules ) as $directive ) {
+			$directive = trim( $directive );
+			if ( '' === $directive ) {
+				continue;
+			}
+			$colon = strpos( $directive, ':' );
+			if ( false === $colon ) {
+				// A comma is the usual separator; "noindex nofollow" is the same pair written with a space.
+				foreach ( explode( ' ', str_replace( "\t", ' ', $directive ) ) as $token ) {
+					if ( in_array( $token, $blocking, true ) ) {
+						return true;
+					}
+				}
+				continue;
+			}
+			$name  = trim( substr( $directive, 0, $colon ) );
+			$value = trim( substr( $directive, $colon + 1 ) );
+			if ( in_array( $name, $valued, true ) ) {
+				continue;
+			}
+			if ( in_array( $name, $blocking, true ) || in_array( $value, $blocking, true ) ) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * The home, shop and product page URLs a visitor would open first; shop and product only when the store has them.
+	 *
+	 * @param StoreResponses $responses Store responses.
+	 * @return string[]
+	 */
+	private static function store_page_urls( StoreResponses $responses ): array {
+		$product = $responses->product();
+		return array_values( array_filter( array( home_url( '/' ), wc_get_page_permalink( 'shop', '' ), null === $product ? '' : (string) $product->get_permalink() ) ) );
+	}
+
+	/**
+	 * Whether the home, shop and product page open without sending the visitor to sign in.
+	 * False when one redirects to wp-login.php or My account. A 401 or 403 is couldn't check:
+	 * a firewall or security plugin can refuse the store's request to itself. Null when one
+	 * couldn't be loaded and none redirected to sign in.
+	 *
+	 * @param StoreResponses $responses Store responses.
+	 */
+	private function pages_public( StoreResponses $responses ): ?bool {
+		$unknown = false;
+		$account = (string) wp_parse_url( wc_get_page_permalink( 'myaccount', '' ), PHP_URL_PATH );
+		foreach ( self::store_page_urls( $responses ) as $url ) {
+			$response = $responses->get( $url );
+			$followed = $responses->redirects( $url );
+			if ( self::sign_in_path( $followed['stopped_at'], $account ) || self::sign_in_path( $followed['final_url'], $account ) ) {
+				return false;
+			}
+			if ( null === $response || self::blocked( $response['status'] ) ) {
+				$unknown = true;
+			}
+		}
+		return $unknown ? null : true;
+	}
+
+	/**
+	 * Whether a URL is the sign-in page or wp-login.php.
+	 *
+	 * @param string $url     URL, or '' when there is none.
+	 * @param string $account Path of the My Account page.
+	 */
+	private static function sign_in_path( string $url, string $account ): bool {
+		$path = (string) wp_parse_url( $url, PHP_URL_PATH );
+		return '' !== $path && ( str_ends_with( $path, '/wp-login.php' ) || ( '' !== $account && '/' !== $account && untrailingslashit( $path ) === untrailingslashit( $account ) ) );
+	}
+
+	/**
+	 * Whether a sitemap the store serves has lastmod dates, in the index or in a child sitemap on this host.
+	 *
+	 * @param StoreResponses $responses Store responses.
+	 */
+	private function sitemap_has_lastmod( StoreResponses $responses ): ?bool {
+		return $this->sitemap_matches(
+			$responses,
+			static fn( string $xml ): bool => false !== stripos( $xml, '<lastmod' )
+		);
+	}
+
+	/**
+	 * Whether the page links to an RSS or Atom feed with a link tag.
+	 *
+	 * @param string $html Page HTML.
+	 */
+	private static function has_feed_link( string $html ): bool {
+		$tags = new \WP_HTML_Tag_Processor( $html );
+		while ( $tags->next_tag( array( 'tag_name' => 'link' ) ) ) {
+			$rel  = strtolower( (string) $tags->get_attribute( 'rel' ) );
+			$type = strtolower( trim( (string) $tags->get_attribute( 'type' ) ) );
+			if ( in_array( 'alternate', explode( ' ', (string) preg_replace( '/\s+/', ' ', $rel ) ), true ) && in_array( $type, array( 'application/rss+xml', 'application/atom+xml' ), true ) && '' !== trim( (string) $tags->get_attribute( 'href' ) ) ) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Whether the page's html element has a lang attribute and the page declares its encoding,
+	 * in a meta tag or the Content-Type header. Null when the page didn't load.
+	 *
+	 * @param array{status:int,body:string,headers:array<string,string>}|null $page Page.
+	 */
+	private static function has_lang_and_charset( ?array $page ): ?bool {
+		if ( null === $page ) {
+			return null;
+		}
+		$tags    = new \WP_HTML_Tag_Processor( $page['body'] );
+		$lang    = $tags->next_tag( array( 'tag_name' => 'html' ) ) && '' !== trim( (string) $tags->get_attribute( 'lang' ) );
+		$charset = false !== stripos( $page['headers']['content-type'] ?? '', 'charset=' );
+		$tags    = new \WP_HTML_Tag_Processor( $page['body'] );
+		while ( ! $charset && $tags->next_tag( array( 'tag_name' => 'meta' ) ) ) {
+			$charset = null !== $tags->get_attribute( 'charset' ) || false !== stripos( (string) $tags->get_attribute( 'content' ), 'charset=' );
+		}
+		return $lang && $charset;
+	}
+
+	/**
+	 * Whether every image has an alt attribute. An empty alt marks a decorative image and counts;
+	 * images hidden from assistive technology don't need one.
+	 *
+	 * @param string $html Page HTML.
+	 */
+	private static function images_have_alt( string $html ): bool {
+		$tags     = new \WP_HTML_Tag_Processor( $html );
+		$noscript = 0;
+		while ( $tags->next_tag( array( 'tag_closers' => 'visit' ) ) ) {
+			if ( 'NOSCRIPT' === $tags->get_tag() ) {
+				$noscript = max( 0, $noscript + ( $tags->is_tag_closer() ? -1 : 1 ) );
+				continue;
+			}
+			if ( 'IMG' !== $tags->get_tag() || $noscript > 0 || null !== $tags->get_attribute( 'alt' ) ) {
+				continue;
+			}
+			// A tracking pixel or an image hidden from assistive technology needs no alt.
+			$pixel  = '1' === (string) $tags->get_attribute( 'width' ) && '1' === (string) $tags->get_attribute( 'height' );
+			$hidden = 'true' === strtolower( (string) $tags->get_attribute( 'aria-hidden' ) ) || in_array( strtolower( (string) $tags->get_attribute( 'role' ) ), array( 'presentation', 'none' ), true );
+			if ( ! $pixel && ! $hidden ) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * How many tags of a name the page has.
+	 *
+	 * @param string $html Page HTML.
+	 * @param string $name Tag name.
+	 */
+	private static function count_tags( string $html, string $name ): int {
+		$tags  = new \WP_HTML_Tag_Processor( $html );
+		$count = 0;
+		while ( $tags->next_tag( array( 'tag_name' => $name ) ) ) {
+			++$count;
+		}
+		return $count;
+	}
+
+	/**
+	 * Whether the page gives the product a valid GTIN, from WooCommerce or any other source. When it doesn't, a
+	 * failure only when WooCommerce would have printed one, the product's own valid GTIN; otherwise null, since
+	 * missing_gtin and invalid_gtin report the stored value.
+	 *
+	 * @param array<int, array<string, mixed>> $products Product items.
+	 * @param \WC_Product|null                 $product  The product of the page.
+	 */
+	private static function served_gtin_ok( array $products, ?\WC_Product $product ): ?bool {
+		if ( null === $product || ! ProductFields::needs_identifiers( $product ) ) {
+			return null;
+		}
+		foreach ( self::served_gtins( self::identifier_items( $products, $product ) ) as $gtin ) {
+			if ( ProductFields::is_valid_gtin( $gtin ) ) {
+				return true;
+			}
+		}
+		// WooCommerce prints the product's own GTIN on its page, never a variation's.
+		$own = (string) preg_replace( '/\D/', '', (string) $product->get_global_unique_id() );
+		return ProductFields::is_valid_gtin( $own ) ? false : null;
+	}
+
+	/**
+	 * GTINs the Product items and their offers give, digits only.
+	 *
+	 * @param array<int, array<string, mixed>> $products Product items.
+	 * @return array<int, string>
+	 */
+	private static function served_gtins( array $products ): array {
+		$gtins = array();
+		// The caller already included variants. Expanding hasVariant again only repeats them.
+		foreach ( array_merge( $products, self::offers_of( $products ) ) as $item ) {
+			foreach ( array( 'gtin', 'gtin8', 'gtin12', 'gtin13', 'gtin14' ) as $key ) {
+				foreach ( self::values( $item[ $key ] ?? null ) as $value ) {
+					$gtin = is_string( $value ) || is_int( $value ) ? (string) preg_replace( '/\D/', '', (string) $value ) : '';
+					if ( '' !== $gtin ) {
+						$gtins[] = $gtin;
+					}
+				}
+			}
+		}
+		return array_values( array_unique( $gtins ) );
+	}
+
+	/**
+	 * Whether the page gives a brand, from WooCommerce or any other source. When it doesn't, a failure only when
+	 * WooCommerce would have printed one: it prints the product's first WooCommerce brand. A brand kept in an
+	 * attribute or another plugin's taxonomy isn't printed by WooCommerce, so its absence is null, not a conflict.
+	 *
+	 * @param array<int, array<string, mixed>> $products Product items.
+	 * @param \WC_Product|null                 $product  The product of the page.
+	 */
+	private static function served_brand_ok( array $products, ?\WC_Product $product ): ?bool {
+		if ( null === $product ) {
+			return null;
+		}
+		foreach ( self::identifier_items( $products, $product ) as $item ) {
+			foreach ( self::values( $item['brand'] ?? null ) as $brand ) {
+				$name = is_array( $brand ) ? ( $brand['name'] ?? null ) : $brand;
+				if ( is_string( $name ) && '' !== trim( $name ) ) {
+					return true;
+				}
+			}
+		}
+		if ( ! taxonomy_exists( 'product_brand' ) ) {
+			return null;
+		}
+		$terms = get_the_terms( $product->get_id(), 'product_brand' );
+		return is_array( $terms ) && array() !== $terms ? false : null;
+	}
+
+	/**
+	 * The Product items that are this product: the ones that name it, or, when none does, the ones whose
+	 * url or @id is its permalink. An upsell that matches neither is left out.
+	 *
+	 * @param array<int, array<string, mixed>> $products Product items.
+	 * @param \WC_Product                      $product  The product of the page.
+	 * @return array<int, array<string, mixed>>
+	 */
+	private static function own_items( array $products, \WC_Product $product ): array {
+		$named = self::naming( $products, $product );
+		if ( array() !== $named ) {
+			return $named;
+		}
+		$permalink = (string) $product->get_permalink();
+		return array_values(
+			array_filter(
+				$products,
+				static function ( array $item ) use ( $permalink ): bool {
+					foreach ( array( 'url', '@id' ) as $key ) {
+						$value = $item[ $key ] ?? null;
+						if ( is_string( $value ) && self::same_page( $value, $permalink ) ) {
+							return true;
+						}
+					}
+					return false;
+				}
+			)
+		);
+	}
+
+	/**
+	 * Whether a JSON-LD url or @id points at this product's permalink. A fragment after # is ignored.
+	 *
+	 * @param string $value     url or @id.
+	 * @param string $permalink Product permalink.
+	 */
+	private static function same_page( string $value, string $permalink ): bool {
+		$hash = strpos( $value, '#' );
+		if ( false !== $hash ) {
+			$value = substr( $value, 0, $hash );
+		}
+		return '' !== $value && self::comparable_url( $value ) === self::comparable_url( $permalink );
+	}
+
+	/**
+	 * A URL compared the way a served page can differ from the stored permalink: entities decoded, scheme and trailing slash dropped.
+	 *
+	 * @param string $url URL.
+	 */
+	private static function comparable_url( string $url ): string {
+		$url   = html_entity_decode( $url, ENT_QUOTES | ENT_HTML5, 'UTF-8' );
+		$lower = strtolower( $url );
+		foreach ( array( 'https:', 'http:' ) as $scheme ) {
+			if ( str_starts_with( $lower, $scheme ) ) {
+				$url = substr( $url, strlen( $scheme ) );
+				break;
+			}
+		}
+		return untrailingslashit( $url );
+	}
+
+	/**
+	 * The Product items whose name is the product's.
+	 *
+	 * @param array<int, array<string, mixed>> $products Product items.
+	 * @param \WC_Product                      $product  The product of the page.
+	 * @return array<int, array<string, mixed>>
+	 */
+	private static function naming( array $products, \WC_Product $product ): array {
+		$name = strtolower( trim( html_entity_decode( $product->get_name(), ENT_QUOTES | ENT_HTML5, 'UTF-8' ) ) );
+		return array_values( array_filter( $products, static fn( array $item ): bool => is_string( $item['name'] ?? null ) && strtolower( trim( html_entity_decode( $item['name'], ENT_QUOTES | ENT_HTML5, 'UTF-8' ) ) ) === $name ) );
+	}
+
+	/**
+	 * Whether a Product item names the product, and, for a product with one price, one of its own items
+	 * offers that price with or without tax; a related product's offer at that price doesn't count.
+	 * Offers without a price aren't judged here: product_offer_jsonld reports them.
+	 *
+	 * @param array<int, array<string, mixed>> $products Product items.
+	 * @param \WC_Product|null                 $product  The product of the page.
+	 */
+	private static function schema_matches( array $products, ?\WC_Product $product ): ?bool {
+		if ( null === $product ) {
+			return null;
+		}
+		if ( array() === self::naming( $products, $product ) ) {
+			return false;
+		}
+		if ( '' === $product->get_price() || $product->is_type( 'variable' ) ) {
+			return true;
+		}
+		$prices   = array();
+		$unparsed = false;
+		foreach ( self::offers( self::own_items( $products, $product ) ) as $offer ) {
+			$values = array( $offer['price'] ?? null, $offer['lowPrice'] ?? null );
+			foreach ( self::as_list( $offer['priceSpecification'] ?? null ) as $specification ) {
+				$type = (string) ( $specification['priceType'] ?? '' );
+				// ListPrice is a price that is not the current one, such as the price before a sale.
+				if ( 'ListPrice' === $type || str_ends_with( $type, '/ListPrice' ) ) {
+					continue;
+				}
+				$values[] = $specification['price'] ?? null;
+			}
+			foreach ( $values as $price ) {
+				if ( null === $price || '' === $price ) {
+					continue;
+				}
+				$amount = self::price_amount( $price );
+				if ( null === $amount ) {
+					$unparsed = true;
+					continue;
+				}
+				$prices[] = $amount;
+			}
+		}
+		if ( array() === $prices ) {
+			return $unparsed ? null : true;
+		}
+		$excl     = (float) wc_get_price_excluding_tax( $product );
+		$expected = array( (float) $product->get_price(), (float) wc_get_price_including_tax( $product ), $excl );
+		// The page was served to one location; its tax may differ from the store's base rate.
+		$rates = $product->is_taxable() ? \WC_Tax::get_rates_for_tax_class( $product->get_tax_class() ) : array();
+		$rates = is_array( $rates ) ? $rates : array();
+		foreach ( $rates as $rate ) {
+			$expected[] = $excl * ( 1 + (float) $rate->tax_rate / 100 );
+		}
+		// WooCommerce prints the JSON-LD price rounded with wc_format_decimal(). With 0 decimals, 9.99 is served as 10.
+		$decimals = wc_get_price_decimals();
+		$printed  = array();
+		foreach ( $expected as $amount ) {
+			$printed[] = (float) wc_format_decimal( $amount, $decimals );
+		}
+		$expected = array_merge( $expected, $printed );
+		foreach ( $prices as $price ) {
+			foreach ( $expected as $amount ) {
+				if ( abs( $price - $amount ) < 0.01 ) {
+					return true;
+				}
+			}
+		}
+		// Several rates of one class can apply together, so a price that matches none of them stays unknown.
+		return count( $rates ) > 1 ? null : false;
+	}
+
+	/**
+	 * Whether the page of a published product with reviews has a rating in its JSON-LD. True when
+	 * reviews are off or no product has any, since there is nothing to mark up.
+	 *
+	 * @param StoreResponses $responses Store responses.
+	 */
+	private function reviews_marked_up( StoreResponses $responses ): ?bool {
+		// WooCommerce prints a rating only when ratings are on and the product has rated reviews; the rating count is stored per star, the average as a number.
+		if ( ! wc_review_ratings_enabled() ) {
+			return true;
+		}
+		// wc_get_products() ignores meta_query, so the reviewed product is looked up as a post.
+		$ids = get_posts(
+			array(
+				'post_type'        => 'product',
+				'post_status'      => ProductStatus::PUBLISH,
+				'has_password'     => false,
+				'posts_per_page'   => 5,
+				'fields'           => 'ids',
+				'orderby'          => 'date',
+				'order'            => 'DESC',
+				'suppress_filters' => false,
+				// phpcs:ignore WordPress.DB.SlowDBQuery.slow_db_query_tax_query -- Five rows, once per background scan.
+				'tax_query'        => array(
+					array(
+						'taxonomy' => 'product_visibility',
+						'field'    => 'slug',
+						'terms'    => array( 'exclude-from-catalog' ),
+						'operator' => 'NOT IN',
+					),
+				),
+				// phpcs:ignore WordPress.DB.SlowDBQuery.slow_db_query_meta_query -- Five rows, once per background scan.
+				'meta_query'       => array(
+					array(
+						'key'     => '_wc_average_rating',
+						'value'   => 0,
+						'compare' => '>',
+						'type'    => 'DECIMAL',
+					),
+				),
+			)
+		);
+		$product = null;
+		foreach ( $ids as $id ) {
+			$candidate = wc_get_product( (int) $id );
+			if ( $candidate instanceof \WC_Product && $candidate->is_visible() ) {
+				$product = $candidate;
+				break;
+			}
+		}
+		if ( null === $product ) {
+			return true;
+		}
+		$sampled = $responses->product();
+		if ( null !== $sampled && $sampled->get_id() === $product->get_id() ) {
+			$page = $responses->product_page();
+			if ( null === $page ) {
+				return null;
+			}
+		} else {
+			$page = $responses->get( (string) $product->get_permalink() );
+			if ( null === $page || 200 !== $page['status'] ) {
+				return null;
+			}
+		}
+		foreach ( self::naming( JsonLd::items( $page['body'], 'Product', 'ProductGroup' ), $product ) as $item ) {
+			if ( ! empty( $item['aggregateRating'] ) || ! empty( $item['review'] ) ) {
+				return true;
+			}
+		}
+		// A cut-off page can hide the rating. That is "couldn't check", not "missing".
+		return $page['truncated'] ? null : false;
+	}
+
+	/**
+	 * Whether the home page links to the privacy policy and refund and returns pages the store set.
+	 * Null when the page didn't load or neither page is set: the page checks report a missing page.
+	 *
+	 * @param array{status:int,body:string,headers:array<string,string>}|null $home Home page.
+	 */
+	private static function links_policy_pages( ?array $home ): ?bool {
+		$pages = array_filter(
+			array_map(
+				static fn( string $option ): int => (int) get_option( $option ),
+				array( AgenticCommerceSettings::PRIVACY_PAGE_OPTION, AgenticCommerceSettings::REFUND_RETURNS_PAGE_OPTION )
+			),
+			static fn( int $id ): bool => $id > 0 && 'publish' === get_post_status( $id )
+		);
+		if ( null === $home || array() === $pages ) {
+			return null;
+		}
+		$links = array();
+		$tags  = new \WP_HTML_Tag_Processor( $home['body'] );
+		while ( $tags->next_tag( array( 'tag_name' => 'a' ) ) ) {
+			$links[] = (string) \WP_Http::make_absolute_url( (string) $tags->get_attribute( 'href' ), home_url( '/' ) );
+		}
+		foreach ( $pages as $id ) {
+			$permalink = (string) get_permalink( $id );
+			foreach ( $links as $link ) {
+				if ( self::same_page( $link, $permalink ) ) {
+					continue 2;
+				}
+			}
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * The offers of the Product items, with those an AggregateOffer lists, one level down.
+	 *
+	 * @param array<int, array<string, mixed>> $products Product items.
+	 * @return array<int, array<string, mixed>>
+	 */
+	private static function offers( array $products ): array {
+		return self::offers_of( self::with_variants( $products ) );
+	}
+
+	/**
+	 * The offers of these items, with those an AggregateOffer lists, one level down.
+	 * Variants are not expanded: the caller includes them when it has them.
+	 *
+	 * @param array<int, array<string, mixed>> $items Product items.
+	 * @return array<int, array<string, mixed>>
+	 */
+	private static function offers_of( array $items ): array {
+		$offers = array();
+		foreach ( $items as $item ) {
+			array_push( $offers, ...self::as_list( $item['offers'] ?? null ) );
+		}
+		$nested = array();
+		foreach ( $offers as $offer ) {
+			array_push( $nested, ...self::as_list( $offer['offers'] ?? null ) );
+		}
+		return array_merge( $offers, $nested );
+	}
 }
diff --git a/plugins/woocommerce/src/Internal/AgentReadiness/StoreResponses.php b/plugins/woocommerce/src/Internal/AgentReadiness/StoreResponses.php
index a27b6234bff..59e2e3f478b 100644
--- a/plugins/woocommerce/src/Internal/AgentReadiness/StoreResponses.php
+++ b/plugins/woocommerce/src/Internal/AgentReadiness/StoreResponses.php
@@ -58,6 +58,13 @@ class StoreResponses {
 	 */
 	private array $responses = array();

+	/**
+	 * How `get()` reached each URL: the redirects it followed, where it stopped when it didn't follow one, and the URL it landed on.
+	 *
+	 * @var array<string, array{stopped_at:string,final_url:string}>
+	 */
+	private array $redirects = array();
+
 	/**
 	 * The product whose page checks read, false when there is none, null until looked up.
 	 *
@@ -65,6 +72,13 @@ class StoreResponses {
 	 */
 	private $product = null;

+	/**
+	 * The category page's URL once looked up; '' when there is none.
+	 *
+	 * @var string|null
+	 */
+	private ?string $category_url = null;
+
 	/**
 	 * Constructor.
 	 *
@@ -83,7 +97,13 @@ class StoreResponses {
 	public function get( string $url ): ?array {
 		$url = self::absolute( $url );
 		if ( ! array_key_exists( $url, $this->responses ) ) {
-			$this->responses[ $url ] = $this->site_live ? $this->fetch( $url ) : null;
+			// product_page() already loaded this URL, under its own key and with a larger cap.
+			$product_key = 'PRODUCT ' . $url;
+			if ( array_key_exists( $product_key, $this->responses ) ) {
+				$this->responses[ $url ] = $this->responses[ $product_key ];
+			} else {
+				$this->responses[ $url ] = $this->site_live ? $this->fetch( $url ) : null;
+			}
 		}
 		return $this->responses[ $url ];
 	}
@@ -92,7 +112,7 @@ class StoreResponses {
 	 * The response when a URL on the store's host is asked for as Markdown. Redirects are not followed.
 	 *
 	 * @param string $url URL or path.
-	 * @return array{status:int,body:string,headers:array<string,string>}|null Null when the store could not be reached.
+	 * @return array{status:int,body:string,headers:array<string,string>,truncated:bool}|null Null when the store could not be reached.
 	 */
 	public function get_as_markdown( string $url ): ?array {
 		$url = self::absolute( $url );
@@ -104,50 +124,104 @@ class StoreResponses {
 	}

 	/**
-	 * The response to a JSON POST to a URL on the store's host, such as a UCP endpoint. Redirects are not followed.
+	 * The URL of a redirect `get()` did not follow for a URL ('' when none), and the URL it landed on.
+	 *
+	 * @param string $url URL or path, as given to `get()`.
+	 * @return array{stopped_at:string,final_url:string}
+	 */
+	public function redirects( string $url ): array {
+		return $this->redirects[ self::absolute( $url ) ] ?? array(
+			'stopped_at' => '',
+			'final_url'  => '',
+		);
+	}
+
+	/**
+	 * The response to a POST of a JSON object, without following redirects.
+	 * Only a URL on the store's host is requested.
 	 *
 	 * @param string               $url  URL or path.
-	 * @param array<string, mixed> $body Request body.
+	 * @param array<string, mixed> $body JSON object. An empty array is sent as {}.
 	 * @return array{status:int,body:string,headers:array<string,string>,truncated:bool}|null Null when the store could not be reached.
 	 */
 	public function post_json( string $url, array $body ): ?array {
-		$url  = self::absolute( $url );
-		$json = (string) wp_json_encode( $body );
-		$key  = 'POST ' . $url . ' ' . $json;
+		$url = self::absolute( $url );
+		$key = 'POST ' . $url;
 		if ( ! array_key_exists( $key, $this->responses ) ) {
 			$this->responses[ $key ] = $this->site_live && $this->is_store_url( $url ) ? $this->request(
 				$url,
 				array(
 					'method'  => 'POST',
 					'headers' => array( 'Content-Type' => 'application/json' ),
-					'body'    => $json,
+					'body'    => (string) wp_json_encode( (object) $body ),
 				)
 			) : null;
 		}
 		return $this->responses[ $key ];
 	}

+	/**
+	 * The shop page, or null when there is none or it didn't answer 200.
+	 *
+	 * @return array{status:int,body:string,headers:array<string,string>,truncated:bool}|null
+	 */
+	public function shop_page(): ?array {
+		$url = wc_get_page_permalink( 'shop', '' );
+		return '' === $url ? null : self::ok( $this->get( $url ) );
+	}
+
+	/**
+	 * The page of a product category with products: one of `product()`'s, else the store's largest. Null when
+	 * there is none or it didn't answer 200.
+	 *
+	 * @return array{status:int,body:string,headers:array<string,string>,truncated:bool}|null
+	 */
+	public function category_page(): ?array {
+		if ( null === $this->category_url ) {
+			$product            = $this->product();
+			$ids                = null === $product ? array() : $product->get_category_ids();
+			$terms              = get_terms(
+				array_merge(
+					array(
+						'taxonomy'   => 'product_cat',
+						'hide_empty' => true,
+						'number'     => 1,
+					),
+					array() === $ids ? array(
+						'orderby' => 'count',
+						'order'   => 'DESC',
+					) : array( 'include' => $ids )
+				)
+			);
+			$term               = is_array( $terms ) ? reset( $terms ) : false;
+			$url                = $term instanceof \WP_Term ? get_term_link( $term ) : '';
+			$this->category_url = is_string( $url ) ? $url : '';
+		}
+		return '' === $this->category_url ? null : self::ok( $this->get( $this->category_url ) );
+	}
+
 	/**
 	 * The newest published product of a type the report checks that is in the shop catalog, or null when there is none.
-	 * Password protected products are skipped, since their page shows a form instead of the product. A product with
+	 * Password protected products are left out, since their page shows a form instead of the product. A product with
 	 * a price comes first, so one unfinished product doesn't decide a check for the whole store; only the five newest
-	 * are looked at.
+	 * of the others are looked at.
 	 */
 	public function product(): ?\WC_Product {
 		if ( null === $this->product ) {
 			$this->product = false;
 			$products      = wc_get_products(
 				array(
-					'status'     => ProductStatus::PUBLISH,
-					'visibility' => CatalogVisibility::CATALOG,
-					'type'       => ProductScan::SUPPORTED_TYPES,
-					'limit'      => 5,
-					'orderby'    => 'date',
-					'order'      => 'DESC',
+					'status'       => ProductStatus::PUBLISH,
+					'visibility'   => CatalogVisibility::CATALOG,
+					'type'         => ProductScan::SUPPORTED_TYPES,
+					'has_password' => false,
+					'limit'        => 5,
+					'orderby'      => 'date',
+					'order'        => 'DESC',
 				)
 			);
 			foreach ( is_array( $products ) ? $products : array() as $product ) {
-				if ( ! $product instanceof \WC_Product || '' !== $product->get_post_password() ) {
+				if ( ! $product instanceof \WC_Product ) {
 					continue;
 				}
 				if ( false === $this->product ) {
@@ -214,20 +288,33 @@ class StoreResponses {
 	 * @return array{status:int,body:string,headers:array<string,string>,truncated:bool}|null
 	 */
 	private function fetch( string $url, int $limit = self::MAX_BYTES ): ?array {
+		$asked = $url;
 		for ( $redirects = 0; $redirects <= self::MAX_REDIRECTS; $redirects++ ) {
+			$this->redirects[ $asked ] = array(
+				'stopped_at' => '',
+				'final_url'  => '',
+			);
 			if ( ! $this->is_store_url( $url ) ) {
+				$this->redirects[ $asked ]['stopped_at'] = $url;
 				return null;
 			}
 			$response = $this->request( $url, array(), $limit );
 			if ( null === $response ) {
+				// When the home page can't be reached, other URLs would fail the same way, so a scan
+				// of a store that can't reach itself waits for one timeout, not one per URL.
+				if ( untrailingslashit( $asked ) === untrailingslashit( home_url( '/' ) ) ) {
+					$this->reachable = false;
+				}
 				return null;
 			}
 			$location = $response['headers']['location'] ?? '';
 			if ( $response['status'] < 300 || $response['status'] >= 400 || '' === $location ) {
+				$this->redirects[ $asked ]['final_url'] = $url;
 				return $response;
 			}
 			$url = \WP_Http::make_absolute_url( $location, $url );
-			if ( is_string( wp_parse_url( $url, PHP_URL_QUERY ) ) ) {
+			if ( is_string( wp_parse_url( $url, PHP_URL_QUERY ) ) || $redirects >= self::MAX_REDIRECTS ) {
+				$this->redirects[ $asked ]['stopped_at'] = $url;
 				return null;
 			}
 		}
@@ -259,16 +346,10 @@ class StoreResponses {
 			)
 		);
 		if ( is_wp_error( $response ) ) {
-			// When the home page can't be reached, other URLs would fail the same way, so a scan
-			// of a store that can't reach itself waits for one timeout, not one per URL. Only the
-			// plain GET counts: a Markdown or POST request can fail where the page itself loads.
-			if ( array() === $args && untrailingslashit( $url ) === untrailingslashit( home_url( '/' ) ) ) {
-				$this->reachable = false;
-			}
 			return null;
 		}
 		$headers = array();
-		foreach ( array( 'location', 'x-robots-tag', 'content-type', 'vary' ) as $name ) {
+		foreach ( array( 'location', 'x-robots-tag', 'content-type', 'vary', 'link' ) as $name ) {
 			$value = wp_remote_retrieve_header( $response, $name );
 			$value = is_array( $value ) ? implode( ', ', $value ) : (string) $value;
 			if ( '' !== $value ) {
diff --git a/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/AgenticCommerceSettingsTest.php b/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/AgenticCommerceSettingsTest.php
index 0cc4e565603..d636084bdad 100644
--- a/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/AgenticCommerceSettingsTest.php
+++ b/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/AgenticCommerceSettingsTest.php
@@ -287,7 +287,7 @@ class AgenticCommerceSettingsTest extends WC_Unit_Test_Case {
 	}

 	/**
-	 * @testdox The page answers each merchant question, marks a likely conflict, hides checks whose prerequisite failed, and folds passed checks away.
+	 * @testdox The page answers each merchant question, marks a likely conflict with the page but names no plugin, hides checks whose prerequisite failed, and folds passed checks away.
 	 */
 	public function test_output_groups_summary_and_conflict(): void {
 		$row = static fn( string $id, ?bool $ok, bool $conflict = false ): array => array(
@@ -307,7 +307,14 @@ class AgenticCommerceSettingsTest extends WC_Unit_Test_Case {
 			array(
 				'generated_at' => gmdate( 'c' ),
 				'store_checks' => array(
-					$row( 'product_jsonld_present', false, true ),
+					array_merge(
+						$row( 'product_jsonld_present', false, true ),
+						array(
+							'seen_at' => 'https://example.org/product/mug/',
+							// A report stored before plugin names were dropped.
+							'plugins' => array( 'Yoast SEO', 'Rank Math SEO' ),
+						)
+					),
 					$row( 'product_offer_jsonld', null ),
 					$row( 'sitemap_lists_products', true ),
 				),
@@ -323,6 +330,8 @@ class AgenticCommerceSettingsTest extends WC_Unit_Test_Case {
 		$this->assertMatchesRegularExpression( '/data-on="(?![^"]*Agent shopping is off)[^"]*" data-off="Agent shopping is off/', $html, 'The switch script can show the line for UCP on without a reload' );
 		$this->assertStringContainsString( 'Likely conflict', $html );
 		$this->assertStringContainsString( 'Something on your store may be replacing this.', $html );
+		$this->assertStringContainsString( 'Seen on: <a href="https://example.org/product/mug/">https://example.org/product/mug/</a>', $html, 'A conflict names the page' );
+		$this->assertStringNotContainsString( 'Yoast SEO', $html, 'No plugin is named, even from an older stored report' );
 		$this->assertStringNotContainsString( 'product_offer_jsonld name', $html, 'Its prerequisite failed' );
 		$this->assertMatchesRegularExpression( '#<details>.*sitemap_lists_products name.*</details>#s', $html );
 	}
diff --git a/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/DeclaredToAgentsTest.php b/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/DeclaredToAgentsTest.php
index e193fe1dbec..7edbf82aeda 100644
--- a/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/DeclaredToAgentsTest.php
+++ b/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/DeclaredToAgentsTest.php
@@ -70,17 +70,13 @@ class DeclaredToAgentsTest extends WC_Unit_Test_Case {
 			array(
 				'/ai.txt'                      => array( 403, 'Forbidden' ),
 				'/.well-known/agent-card.json' => array( 401, '' ),
-				'/feed/'                       => array( 403, '' ),
 				'markdown /'                   => array( 403, '' ),
-				'/sitemap.xml'                 => array( 403, '' ),
 			)
 		);

 		$this->assertNull( $results['ai-txt'] );
 		$this->assertNull( $results['a2a-agent-card'] );
-		$this->assertNull( $results['feed-present'] );
 		$this->assertNull( $results['markdown-pages'] );
-		$this->assertNull( $results['sitemap-lastmod'] );
 	}

 	/**
@@ -228,49 +224,88 @@ class DeclaredToAgentsTest extends WC_Unit_Test_Case {
 	}

 	/**
-	 * @testdox lastmod is read from a sitemap or from the first sitemap an index lists.
+	 * @testdox The API catalog, llms-full.txt and a Link header to agent resources are found when served.
 	 */
-	public function test_sitemap_lastmod(): void {
-		$child = home_url( '/products.xml' );
-		$this->assertTrue( $this->results( array( '/sitemap.xml' => array( 200, '<urlset><url><loc>a</loc><lastmod>2026-01-01</lastmod></url></urlset>' ) ) )['sitemap-lastmod'] );
-		remove_all_filters( 'pre_http_request' );
-		$this->assertFalse( $this->results( array( '/sitemap.xml' => array( 200, '<urlset><url><loc>a</loc></url></urlset>' ) ) )['sitemap-lastmod'] );
+	public function test_api_catalog_llms_full_and_link_header(): void {
+		$results = $this->results(
+			array(
+				'/.well-known/api-catalog' => array( 200, '{"linkset":[{"anchor":"https://example.com/wp-json/"}]}' ),
+				'/llms-full.txt'           => array( 200, '# Store' ),
+				'/'                        => array( 200, '<html></html>', array( 'link' => '</.well-known/api-catalog>; rel="api-catalog"' ) ),
+			)
+		);
+		$this->assertTrue( $results['api-catalog'] );
+		$this->assertTrue( $results['llms-full'] );
+		$this->assertTrue( $results['link-header-agent-resources'] );
+
 		remove_all_filters( 'pre_http_request' );
-		$this->assertTrue(
-			$this->results(
-				array(
-					'/sitemap.xml'  => array( 200, "<sitemapindex><sitemap><loc>$child</loc></sitemap></sitemapindex>" ),
-					'/products.xml' => array( 200, '<urlset><url><loc>a</loc><lastmod>2026-01-01</lastmod></url></urlset>' ),
-				)
-			)['sitemap-lastmod']
+		$results = $this->results(
+			array(
+				'/.well-known/api-catalog' => array( 200, '{"error":"not found"}' ),
+				'/'                        => array( 200, '<html></html>', array( 'link' => '<https://example.com/wp-json/>; rel="https://api.w.org/"' ) ),
+			)
 		);
+		$this->assertFalse( $results['api-catalog'], 'A JSON error is not a catalog' );
+		$this->assertFalse( $results['llms-full'] );
+		$this->assertFalse( $results['link-header-agent-resources'], 'The REST API link is not an agent resource' );
+
+		remove_all_filters( 'pre_http_request' );
+		$results = $this->results( array( '/' => array( 200, '<html></html>', array( 'link' => '</llms.txt>; rel="alternate"; type="text/plain"' ) ) ) );
+		$this->assertTrue( $results['link-header-agent-resources'], 'A link to llms.txt counts' );
+
+		$host = (string) wp_parse_url( home_url(), PHP_URL_HOST );
+		foreach ( array( '<llms.txt>; rel="alternate"', '<./llms.txt>; rel="alternate"', '<https://' . $host . '/llms.txt>; rel="alternate"' ) as $header ) {
+			remove_all_filters( 'pre_http_request' );
+			$results = $this->results( array( '/' => array( 200, '<html></html>', array( 'link' => $header ) ) ) );
+			$this->assertTrue( $results['link-header-agent-resources'], $header );
+		}
+
+		foreach ( array( '</llms.txt.bak>; rel="preload"', '</docs/llms.txt>; rel="alternate"', '<https://other.example/llms.txt>; rel="alternate"', '</.well-known/api-catalog>; rel="not-api-catalog"', '</a>; title="rel=api-catalog"', '</a>; title="x; rel=api-catalog"' ) as $header ) {
+			remove_all_filters( 'pre_http_request' );
+			$results = $this->results( array( '/' => array( 200, '<html></html>', array( 'link' => $header ) ) ) );
+			$this->assertFalse( $results['link-header-agent-resources'], $header );
+		}
+		remove_all_filters( 'pre_http_request' );
+		$results = $this->results( array( '/' => array( 200, '<html></html>', array( 'link' => '<https://example.com/wp-json/>; rel="https://api.w.org/", </.well-known/api-catalog>; rel="service-desc api-catalog"' ) ) ) );
+		$this->assertTrue( $results['link-header-agent-resources'], 'The second of two values, with two rel tokens' );
+
+		remove_all_filters( 'pre_http_request' );
+		$results = $this->results( array( '/' => array( 200, '<html></html>', array( 'link' => '</.well-known/api-catalog>; rel=api-catalog' ) ) ) );
+		$this->assertTrue( $results['link-header-agent-resources'], 'An unquoted rel' );
 	}

 	/**
-	 * @testdox lastmod is not found on a sitemap without dates, and not checked when a sitemap or robots.txt fails.
+	 * @testdox A relative llms.txt link is the file at the host root when WordPress is in a subdirectory.
 	 */
-	public function test_sitemap_lastmod_unknown(): void {
-		$child = home_url( '/products.xml' );
-		$index = array( 200, "<sitemapindex><sitemap><loc>$child</loc></sitemap></sitemapindex>" );
-		$this->assertFalse(
-			$this->results(
-				array(
-					'/sitemap.xml'  => $index,
-					'/products.xml' => array( 200, '<urlset><url><loc>a</loc></url></urlset>' ),
-				)
-			)['sitemap-lastmod']
-		);
-		remove_all_filters( 'pre_http_request' );
-		$this->assertNull(
-			$this->results(
-				array(
-					'/sitemap.xml'  => $index,
-					'/products.xml' => array( 503, '' ),
-				)
-			)['sitemap-lastmod']
+	public function test_llms_txt_link_in_a_subdirectory(): void {
+		add_filter(
+			'home_url',
+			static function ( $url ) {
+				$parts = wp_parse_url( (string) $url );
+				if ( ! is_array( $parts ) || empty( $parts['host'] ) ) {
+					return $url;
+				}
+				$path = $parts['path'] ?? '';
+				if ( '/shop' === $path || str_starts_with( $path, '/shop/' ) ) {
+					return $url;
+				}
+				$built = ( $parts['scheme'] ?? 'http' ) . '://' . $parts['host'];
+				if ( isset( $parts['port'] ) ) {
+					$built .= ':' . $parts['port'];
+				}
+				$built .= '/shop' . $path;
+				if ( isset( $parts['query'] ) ) {
+					$built .= '?' . $parts['query'];
+				}
+				return $built;
+			}
 		);
-		remove_all_filters( 'pre_http_request' );
-		$this->assertNull( $this->results( array( '/robots.txt' => array( 403, '' ) ) )['sitemap-lastmod'] );
+		try {
+			$results = $this->results( array( '/' => array( 200, '<html></html>', array( 'link' => '<llms.txt>; rel="alternate"' ) ) ) );
+			$this->assertTrue( $results['link-header-agent-resources'], 'llms.txt is at the host root, not under /shop' );
+		} finally {
+			remove_all_filters( 'home_url' );
+		}
 	}

 	/**
@@ -312,32 +347,28 @@ class DeclaredToAgentsTest extends WC_Unit_Test_Case {
 	}

 	/**
-	 * @testdox The feed and home page structured data are read from what the store serves.
+	 * @testdox Home page structured data are read from what the store serves.
 	 */
-	public function test_feed_and_home_page(): void {
+	public function test_home_page_structured_data(): void {
 		$results = $this->results(
 			array(
-				'/feed/' => array( 200, '<?xml version="1.0"?><rss version="2.0"></rss>' ),
-				'/'      => array( 200, '<html><head><script type="application/ld+json">{"@type":"WebSite","potentialAction":{"@type":"SearchAction"}}</script></head></html>' ),
+				'/' => array( 200, '<html><head><script type="application/ld+json">{"@type":"WebSite","potentialAction":{"@type":"SearchAction"}}</script></head></html>' ),
 			)
 		);

-		$this->assertTrue( $results['feed-present'] );
 		$this->assertTrue( $results['site-search-action'] );
 		$this->assertFalse( $results['sameas-links'] );
 	}

 	/**
-	 * @testdox A failing feed is not checked, and only a SearchAction counts as on-site search.
+	 * @testdox Only a SearchAction counts as on-site search.
 	 */
-	public function test_failing_feed_and_other_actions(): void {
+	public function test_only_search_action_counts(): void {
 		$results = $this->results(
 			array(
-				'/feed/' => array( 503, '' ),
-				'/'      => array( 200, '<html><script type="application/ld+json">{"@type":"WebSite","potentialAction":{"@type":"ReadAction"}}</script></html>' ),
+				'/' => array( 200, '<html><script type="application/ld+json">{"@type":"WebSite","potentialAction":{"@type":"ReadAction"}}</script></html>' ),
 			)
 		);
-		$this->assertNull( $results['feed-present'] );
 		$this->assertFalse( $results['site-search-action'] );

 		remove_all_filters( 'pre_http_request' );
diff --git a/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/RegressionGuardChecksTest.php b/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/RegressionGuardChecksTest.php
new file mode 100644
index 00000000000..16fafb79d0d
--- /dev/null
+++ b/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/RegressionGuardChecksTest.php
@@ -0,0 +1,696 @@
+<?php
+declare( strict_types = 1 );
+
+namespace Automattic\WooCommerce\Tests\Internal\AgentReadiness;
+
+use Automattic\WooCommerce\Internal\AgentReadiness\AgenticCommerceSettings;
+use Automattic\WooCommerce\Internal\AgentReadiness\StoreOutputChecks;
+use Automattic\WooCommerce\Internal\AgentReadiness\StoreResponses;
+use WC_Helper_Product;
+use WC_Structured_Data;
+use WC_Unit_Test_Case;
+
+/**
+ * Tests for the store checks that a stock store passes today, kept so a merchant hears when a host, theme or plugin breaks one.
+ */
+class RegressionGuardChecksTest extends WC_Unit_Test_Case {
+
+	private const GUARDS = array(
+		'no_noindex_directives',
+		'pages_public',
+		'sitemap_lastmod',
+		'rss_feed',
+		'viewport_meta',
+		'html_lang_and_charset',
+		'images_have_alt',
+		'single_h1',
+		'schema_matches_product',
+		'product_review_markup',
+		'policy_pages_linked',
+	);
+
+	/**
+	 * The product whose page the checks read.
+	 *
+	 * @var \WC_Product
+	 */
+	private $product;
+
+	/**
+	 * Pretty permalinks, a product, and published privacy and returns pages.
+	 */
+	public function setUp(): void {
+		parent::setUp();
+		$this->set_permalink_structure( '/%postname%/' );
+		update_option( 'woocommerce_coming_soon', 'no' );
+		$this->product = WC_Helper_Product::create_simple_product();
+		foreach ( array( AgenticCommerceSettings::PRIVACY_PAGE_OPTION, AgenticCommerceSettings::REFUND_RETURNS_PAGE_OPTION ) as $option ) {
+			update_option(
+				$option,
+				self::factory()->post->create(
+					array(
+						'post_type'   => 'page',
+						'post_status' => 'publish',
+					)
+				)
+			);
+		}
+	}
+
+	/**
+	 * Restore plain permalinks, which live on the global rewrite object outside the rollback.
+	 */
+	public function tearDown(): void {
+		try {
+			remove_all_filters( 'pre_http_request' );
+			$this->set_permalink_structure( '' );
+		} finally {
+			parent::tearDown();
+		}
+	}
+
+	/**
+	 * Path of a URL from the home URL.
+	 *
+	 * @param string $url URL.
+	 */
+	private static function path( string $url ): string {
+		return substr( $url, strlen( untrailingslashit( home_url() ) ) );
+	}
+
+	/**
+	 * The responses of a healthy store, by path: status, body and headers.
+	 *
+	 * @return array<string, array{0:int,1:string,2?:array<string,string>}>
+	 */
+	private function healthy_store(): array {
+		$structured_data = new WC_Structured_Data();
+		$structured_data->generate_product_data( $this->product );
+		$jsonld  = wc_esc_json( (string) wp_json_encode( $structured_data->get_structured_data( array() ), JSON_HEX_TAG | JSON_UNESCAPED_SLASHES ), true );
+		$head    = '<!doctype html><html lang="en-US"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width">';
+		$privacy = (string) get_permalink( (int) get_option( AgenticCommerceSettings::PRIVACY_PAGE_OPTION ) );
+		$returns = (string) get_permalink( (int) get_option( AgenticCommerceSettings::REFUND_RETURNS_PAGE_OPTION ) );
+		return array(
+			'/robots.txt'                                 => array( 200, "User-agent: *\nDisallow: /wp-admin/\n\nSitemap: " . home_url( '/wp-sitemap.xml' ) . "\n" ),
+			'/wp-sitemap.xml'                             => array( 200, '<urlset><url><loc>' . $this->product->get_permalink() . '</loc><lastmod>2026-11-01</lastmod></url></urlset>' ),
+			'/'                                           => array( 200, $head . '<link rel="alternate" type="application/rss+xml" href="/feed/"></head><body><h1>Store</h1><img src="a.jpg" alt="Mug"><img src="line.png" alt=""><footer><a href="' . $privacy . '#details">Privacy</a> <a href="' . $returns . '">Returns</a></footer></body></html>' ),
+			self::path( $this->product->get_permalink() ) => array( 200, $head . '<script type="application/ld+json">' . $jsonld . '</script></head><body><h1>' . $this->product->get_name() . '</h1><p>' . wc_price( (float) $this->product->get_price() ) . '</p><img src="p.jpg" alt="Front"></body></html>' ),
+		);
+	}
+
+	/**
+	 * Serve responses by path. Any other path is a 404.
+	 *
+	 * @param array<string, array{0:int,1:string,2?:array<string,string>}> $responses Responses by path.
+	 * @return array<string, bool|null> Results by check id.
+	 */
+	private function results( array $responses ): array {
+		add_filter(
+			'pre_http_request',
+			static function ( $pre, $args, $url ) use ( $responses ) {
+				unset( $pre, $args ); // Avoid parameter not used PHPCS errors.
+				$response = $responses[ self::path( $url ) ] ?? array( 404, '' );
+				return array(
+					'headers'  => $response[2] ?? array(),
+					'body'     => $response[1],
+					'response' => array(
+						'code'    => $response[0],
+						'message' => '',
+					),
+					'cookies'  => array(),
+				);
+			},
+			10,
+			3
+		);
+		return array_column( wc_get_container()->get( StoreOutputChecks::class )->all(), 'ok', 'id' );
+	}
+
+	/**
+	 * @testdox A store that serves what a stock store serves passes every regression guard.
+	 */
+	public function test_healthy_store_passes(): void {
+		$results = $this->results( $this->healthy_store() );
+
+		foreach ( self::GUARDS as $id ) {
+			$this->assertTrue( $results[ $id ], $id );
+		}
+	}
+
+	/**
+	 * @testdox When the store can't reach itself, the guards that read pages are couldn't check.
+	 */
+	public function test_unreachable_store(): void {
+		add_filter( 'pre_http_request', static fn() => new \WP_Error( 'http_request_failed', 'Blocked in tests' ) );
+
+		$results = array_column( wc_get_container()->get( StoreOutputChecks::class )->all(), 'ok', 'id' );
+
+		foreach ( array_diff( self::GUARDS, array( 'product_review_markup' ) ) as $id ) {
+			$this->assertNull( $results[ $id ], $id );
+		}
+		$this->assertTrue( $results['product_review_markup'], 'No product has reviews, so there is nothing to mark up and no page is loaded' );
+	}
+
+	/**
+	 * @testdox noindex, noai and none fail in a robots meta tag or an X-Robots-Tag header; noarchive and a preview size of none don't.
+	 */
+	public function test_noindex_directives(): void {
+		$store      = $this->healthy_store();
+		$store['/'] = array( 200, '<html><head><meta name="robots" content="max-image-preview:large, noarchive"></head></html>' );
+		$this->assertTrue( $this->results( $store )['no_noindex_directives'] );
+
+		remove_all_filters( 'pre_http_request' );
+		$store['/'] = array( 200, '<html><head><meta name="robots" content="index, follow, max-image-preview:none, max-video-preview:none"></head></html>' );
+		$this->assertTrue( $this->results( $store )['no_noindex_directives'], 'none as a preview size is not the none directive' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store['/'] = array( 200, '<html><head><meta name="robots" content="index, follow, max-image-preview: none, max-video-preview: none"></head></html>' );
+		$this->assertTrue( $this->results( $store )['no_noindex_directives'], 'none as a preview size, with a space, is not the none directive' );
+
+		foreach ( array( '<meta name="robots" content="noindex, follow">', '<meta name="robots" content="noindex nofollow">', '<meta name="googlebot" content="none">', '<meta name="googlebot-news" content="noindex">', '<meta name="robots" content="noai, noimageai">' ) as $tag ) {
+			remove_all_filters( 'pre_http_request' );
+			$store['/'] = array( 200, '<html><head>' . $tag . '</head></html>' );
+			$this->assertFalse( $this->results( $store )['no_noindex_directives'], $tag );
+		}
+
+		remove_all_filters( 'pre_http_request' );
+		$store             = $this->healthy_store();
+		$path              = self::path( $this->product->get_permalink() );
+		$store[ $path ][2] = array( 'x-robots-tag' => 'noindex' );
+		$this->assertFalse( $this->results( $store )['no_noindex_directives'], 'Header' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store          = $this->healthy_store();
+		$store['/']     = array( 200, '<html><head><meta name="robots" content="noindex"></head></html>' );
+		$store[ $path ] = array( 404, '' );
+		$this->assertFalse( $this->results( $store )['no_noindex_directives'], 'A noindex home page fails even when the product page did not load' );
+	}
+
+	/**
+	 * @testdox A redirect to the sign-in page is a login wall. A 403 or another failure is couldn't check.
+	 */
+	public function test_login_wall(): void {
+		$path           = self::path( $this->product->get_permalink() );
+		$store          = $this->healthy_store();
+		$store[ $path ] = array( 403, 'Members only' );
+		$this->assertNull( $this->results( $store )['pages_public'], 'A 403 can be a firewall refusing the store its own page' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store[ $path ] = array( 302, '', array( 'location' => site_url( '/wp-login.php?redirect_to=x' ) ) );
+		$this->assertFalse( $this->results( $store )['pages_public'] );
+
+		remove_all_filters( 'pre_http_request' );
+		update_option(
+			'woocommerce_myaccount_page_id',
+			self::factory()->post->create(
+				array(
+					'post_type'   => 'page',
+					'post_status' => 'publish',
+					'post_name'   => 'my-account',
+					'post_title'  => 'My account',
+				)
+			)
+		);
+		$account                         = wc_get_page_permalink( 'myaccount' );
+		$store[ $path ]                  = array( 302, '', array( 'location' => $account ) );
+		$store[ self::path( $account ) ] = array( 200, '<html>Sign in</html>' );
+		$this->assertFalse( $this->results( $store )['pages_public'], 'A followed redirect to the account page is a login wall' );
+
+		remove_all_filters( 'pre_http_request' );
+		unset( $store[ self::path( $account ) ] );
+		$store[ $path ]         = array( 302, '', array( 'location' => site_url( '/wp-login.php' ) ) );
+		$store['/wp-login.php'] = array( 200, '<html>Log in</html>' );
+		$this->assertFalse( $this->results( $store )['pages_public'], 'A followed redirect to wp-login.php is a login wall' );
+
+		remove_all_filters( 'pre_http_request' );
+		unset( $store['/wp-login.php'] );
+		$store[ $path ]  = array( 302, '', array( 'location' => home_url( '/hop-1' ) ) );
+		$store['/hop-1'] = array( 302, '', array( 'location' => home_url( '/hop-2' ) ) );
+		$store['/hop-2'] = array( 302, '', array( 'location' => site_url( '/wp-login.php' ) ) );
+		$this->assertFalse( $this->results( $store )['pages_public'], 'A login redirect past the follow limit is still a login wall' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store[ $path ] = array( 503, '' );
+		$this->assertNull( $this->results( $store )['pages_public'], 'A server error is couldn\'t check' );
+	}
+
+	/**
+	 * @testdox Missing markup fails each page guard.
+	 */
+	public function test_missing_markup(): void {
+		$path           = self::path( $this->product->get_permalink() );
+		$store          = $this->healthy_store();
+		$store['/']     = array( 200, '<html><head></head><body><img src="a.jpg"></body></html>' );
+		$store[ $path ] = array( 200, str_replace( '</h1>', '</h1><h1>Related</h1>', $store[ $path ][1] ) );
+
+		$results = $this->results( $store );
+
+		foreach ( array( 'rss_feed', 'viewport_meta', 'html_lang_and_charset', 'images_have_alt', 'single_h1', 'policy_pages_linked' ) as $id ) {
+			$this->assertFalse( $results[ $id ], $id );
+		}
+	}
+
+	/**
+	 * @testdox A charset in the Content-Type header counts; an image hidden from assistive technology, a noscript fallback or a tracking pixel needs no alt.
+	 */
+	public function test_header_charset_and_hidden_images(): void {
+		$store      = $this->healthy_store();
+		$store['/'] = array( 200, '<html lang="de"><body><img src="x.gif" aria-hidden="true"><noscript><img src="pixel" /></noscript><img src="px.gif" width="1" height="1" style="display:none" /></body></html>', array( 'content-type' => 'text/html; charset=UTF-8' ) );
+
+		$results = $this->results( $store );
+
+		$this->assertTrue( $results['html_lang_and_charset'] );
+		$this->assertTrue( $results['images_have_alt'], 'A noscript fallback and a tracking pixel need no alt' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store['/'] = array( 200, '<html lang="de"><body><noscript><img src="pixel" /></noscript><img src="hero.jpg"></body></html>', array( 'content-type' => 'text/html; charset=UTF-8' ) );
+		$this->assertFalse( $this->results( $store )['images_have_alt'], 'A visible image after the noscript block still needs alt' );
+	}
+
+	/**
+	 * @testdox Structured data with another name or price than the product fails.
+	 */
+	public function test_schema_mismatch(): void {
+		$path           = self::path( $this->product->get_permalink() );
+		$jsonld         = array(
+			'@type'  => 'Product',
+			'@id'    => $this->product->get_permalink() . '#product',
+			'name'   => $this->product->get_name(),
+			'offers' => array(
+				'@type'         => 'Offer',
+				'price'         => '99.00',
+				'priceCurrency' => 'USD',
+				'availability'  => 'https://schema.org/InStock',
+			),
+		);
+		$store          = $this->healthy_store();
+		$store[ $path ] = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( $jsonld ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+		$this->assertFalse( $this->results( $store )['schema_matches_product'], 'Price' );
+
+		remove_all_filters( 'pre_http_request' );
+		$jsonld['offers']['price'] = '99.00 USD';
+		$store[ $path ]            = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( $jsonld ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+		$this->assertFalse( $this->results( $store )['schema_matches_product'], 'A price with a currency code' );
+
+		foreach ( array( 'R$ 10,00', 'US$10', 'S/. 10', 'EUR 10,-' ) as $price ) {
+			remove_all_filters( 'pre_http_request' );
+			$jsonld['name']            = $this->product->get_name();
+			$jsonld['offers']['price'] = $price;
+			$store[ $path ]            = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( $jsonld ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+			$this->assertTrue( $this->results( $store )['schema_matches_product'], $price );
+		}
+
+		remove_all_filters( 'pre_http_request' );
+		$jsonld['offers']['price'] = $this->product->get_price();
+		$jsonld['name']            = 'Another product';
+		$store[ $path ]            = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( $jsonld ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+		$this->assertFalse( $this->results( $store )['schema_matches_product'], 'Name' );
+
+		remove_all_filters( 'pre_http_request' );
+		$jsonld['name']            = $this->product->get_name();
+		$jsonld['offers']['price'] = '99.00';
+		$related                   = array(
+			'@type'  => 'Product',
+			'name'   => 'Related product',
+			'offers' => array(
+				'@type'         => 'Offer',
+				'price'         => $this->product->get_price(),
+				'priceCurrency' => 'USD',
+			),
+		);
+		$store[ $path ]            = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( array( $jsonld, $related ) ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+		$this->assertFalse( $this->results( $store )['schema_matches_product'], 'A related product at the right price doesn\'t stand in for the product\'s own offer' );
+
+		remove_all_filters( 'pre_http_request' );
+		unset( $jsonld['offers']['price'] );
+		$jsonld['offers']['@type']    = 'AggregateOffer';
+		$jsonld['offers']['lowPrice'] = '99.00';
+		$store[ $path ]               = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( $jsonld ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+		$this->assertFalse( $this->results( $store )['schema_matches_product'], 'An AggregateOffer lowPrice is the price' );
+
+		remove_all_filters( 'pre_http_request' );
+		$jsonld['offers'] = array(
+			'@type'              => 'Offer',
+			'price'              => '8.00',
+			'priceCurrency'      => 'USD',
+			'availability'       => 'https://schema.org/InStock',
+			'priceSpecification' => array(
+				'@type'         => 'UnitPriceSpecification',
+				'priceType'     => 'https://schema.org/ListPrice',
+				'price'         => $this->product->get_price(),
+				'priceCurrency' => 'USD',
+			),
+		);
+		$store[ $path ]   = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( $jsonld ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+		$this->assertFalse( $this->results( $store )['schema_matches_product'], 'A list price is not the current price' );
+	}
+
+	/**
+	 * @testdox A price WooCommerce prints rounded to the store's decimals matches. A different amount does not.
+	 */
+	public function test_schema_price_rounded_to_store_decimals(): void {
+		update_option( 'woocommerce_price_num_decimals', '0' );
+		$this->product->set_regular_price( '9.99' );
+		$this->product->set_price( '9.99' );
+		$this->product->save();
+
+		$path           = self::path( $this->product->get_permalink() );
+		$jsonld         = array(
+			'@type'  => 'Product',
+			'@id'    => $this->product->get_permalink() . '#product',
+			'name'   => $this->product->get_name(),
+			'offers' => array(
+				'@type'         => 'Offer',
+				'price'         => '10',
+				'priceCurrency' => 'USD',
+				'availability'  => 'https://schema.org/InStock',
+			),
+		);
+		$store          = $this->healthy_store();
+		$store[ $path ] = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( $jsonld ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+		$this->assertTrue( $this->results( $store )['schema_matches_product'], '9.99 printed with 0 decimals is 10' );
+
+		remove_all_filters( 'pre_http_request' );
+		$jsonld['offers']['price'] = '12';
+		$store[ $path ]            = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( $jsonld ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+		$this->assertFalse( $this->results( $store )['schema_matches_product'], 'A different rounded price is still a conflict' );
+	}
+
+	/**
+	 * @testdox A served price at another tax rate of the product's tax class matches: the page was served to one location.
+	 */
+	public function test_schema_price_at_another_tax_rate(): void {
+		update_option( 'woocommerce_calc_taxes', 'yes' );
+		$second = 0;
+		$rate   = \WC_Tax::_insert_tax_rate(
+			array(
+				'tax_rate_country' => 'DE',
+				'tax_rate'         => '25.0000',
+				'tax_rate_name'    => 'VAT',
+				'tax_rate_class'   => '',
+			)
+		);
+		try {
+			$path           = self::path( $this->product->get_permalink() );
+			$jsonld         = array(
+				'@type'  => 'Product',
+				'@id'    => $this->product->get_permalink() . '#product',
+				'name'   => $this->product->get_name(),
+				'offers' => array(
+					'@type'         => 'Offer',
+					'price'         => number_format( (float) $this->product->get_price() * 1.25, 2, '.', '' ),
+					'priceCurrency' => 'USD',
+					'availability'  => 'https://schema.org/InStock',
+				),
+			);
+			$store          = $this->healthy_store();
+			$store[ $path ] = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( $jsonld ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+			$this->assertTrue( $this->results( $store )['schema_matches_product'] );
+
+			remove_all_filters( 'pre_http_request' );
+			$this->product->set_tax_status( 'none' );
+			$this->product->save();
+			$this->assertFalse( $this->results( $store )['schema_matches_product'], 'A non-taxable product is not priced at a stored tax rate' );
+
+			remove_all_filters( 'pre_http_request' );
+			$this->product->set_tax_status( 'taxable' );
+			$this->product->save();
+			$second = \WC_Tax::_insert_tax_rate(
+				array(
+					'tax_rate_country' => 'FR',
+					'tax_rate'         => '5.0000',
+					'tax_rate_name'    => 'VAT',
+					'tax_rate_class'   => '',
+				)
+			);
+
+			$jsonld['offers']['price'] = '99.00';
+			$store[ $path ]            = array( 200, '<html><script type="application/ld+json">' . wp_json_encode( $jsonld ) . '</script><h1>' . $this->product->get_name() . '</h1></html>' );
+			$this->assertNull( $this->results( $store )['schema_matches_product'], 'Two rates of one class can apply together, so an unmatched price stays unknown' );
+		} finally {
+			if ( $second ) {
+				\WC_Tax::_delete_tax_rate( $second );
+			}
+			\WC_Tax::_delete_tax_rate( $rate );
+			delete_option( 'woocommerce_calc_taxes' );
+		}
+	}
+
+	/**
+	 * @testdox A product with rated reviews needs a rating in its structured data; text-only reviews or ratings turned off need none.
+	 */
+	public function test_review_markup(): void {
+		update_option( 'woocommerce_enable_reviews', 'yes' );
+		update_option( 'woocommerce_enable_review_rating', 'yes' );
+		$reviewed = WC_Helper_Product::create_simple_product();
+		update_post_meta( $reviewed->get_id(), '_wc_review_count', 3 );
+		$path = self::path( $reviewed->get_permalink() );
+
+		$store          = $this->healthy_store();
+		$store[ $path ] = array( 200, '<script type="application/ld+json">{"@type":"Product","name":"Mug"}</script>' );
+		$this->assertTrue( $this->results( $store )['product_review_markup'], 'Reviews without a rating get no rating markup' );
+
+		update_post_meta( $reviewed->get_id(), '_wc_average_rating', '4.50' );
+		remove_all_filters( 'pre_http_request' );
+		$store[ $path ] = array(
+			200,
+			'<script type="application/ld+json">' . wp_json_encode(
+				array(
+					'@type' => 'Product',
+					'name'  => $reviewed->get_name(),
+				)
+			) . '</script>',
+		);
+		$this->assertFalse( $this->results( $store )['product_review_markup'] );
+
+		update_option( 'woocommerce_enable_review_rating', 'no' );
+		remove_all_filters( 'pre_http_request' );
+		$this->assertTrue( $this->results( $store )['product_review_markup'], 'Ratings off: WooCommerce prints none' );
+
+		update_option( 'woocommerce_enable_review_rating', 'yes' );
+		remove_all_filters( 'pre_http_request' );
+		$store[ $path ] = array(
+			200,
+			'<script type="application/ld+json">' . wp_json_encode(
+				array(
+					'@type'           => 'Product',
+					'name'            => $reviewed->get_name(),
+					'aggregateRating' => array(
+						'@type'       => 'AggregateRating',
+						'ratingValue' => '4.5',
+						'reviewCount' => '3',
+					),
+				)
+			) . '</script>',
+		);
+		$this->assertTrue( $this->results( $store )['product_review_markup'] );
+
+		remove_all_filters( 'pre_http_request' );
+		$store[ $path ] = array( 200, '<script type="application/ld+json">{"@type":"Product","name":"Other","aggregateRating":{"@type":"AggregateRating","ratingValue":"4.5","reviewCount":"3"}}</script>' );
+		$this->assertFalse( $this->results( $store )['product_review_markup'], 'A related product\'s rating does not mark up this product' );
+	}
+
+	/**
+	 * @testdox A review page cut off before its rating is couldn't check. The sampled product is read past the short page limit.
+	 */
+	public function test_truncated_review_page_is_unknown(): void {
+		update_option( 'woocommerce_enable_reviews', 'yes' );
+		update_option( 'woocommerce_enable_review_rating', 'yes' );
+		$this->product->set_date_created( time() - HOUR_IN_SECONDS );
+		$this->product->save();
+		$reviewed = WC_Helper_Product::create_simple_product();
+		update_post_meta( $reviewed->get_id(), '_wc_average_rating', '4.50' );
+		$path   = self::path( $reviewed->get_permalink() );
+		$rating = '<script type="application/ld+json">' . wp_json_encode(
+			array(
+				'@type'           => 'Product',
+				'name'            => $reviewed->get_name(),
+				'aggregateRating' => array(
+					'@type'       => 'AggregateRating',
+					'ratingValue' => '4.5',
+				),
+			)
+		) . '</script>';
+
+		$store          = $this->healthy_store();
+		$store[ $path ] = array( 200, str_repeat( 'x', StoreResponses::MAX_BYTES ) . $rating );
+		$this->assertTrue( $this->results( $store )['product_review_markup'], 'The sampled product is read past the short page limit' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store[ $path ] = array( 200, '<html></html>', array( 'content-length' => '99999999' ) );
+		$this->assertNull( $this->results( $store )['product_review_markup'], 'A page cut off before the rating is couldn\'t check' );
+
+		$reviewed->set_date_created( time() - HOUR_IN_SECONDS );
+		$reviewed->save();
+		$this->product->set_date_created( time() );
+		$this->product->save();
+		remove_all_filters( 'pre_http_request' );
+		$this->assertNull( $this->results( $store )['product_review_markup'], 'A different product\'s page, cut off, is couldn\'t check' );
+	}
+
+	/**
+	 * @testdox When the newest reviewed product is hidden, the next visible reviewed product is read.
+	 */
+	public function test_review_markup_skips_hidden_products(): void {
+		update_option( 'woocommerce_enable_reviews', 'yes' );
+		update_option( 'woocommerce_enable_review_rating', 'yes' );
+		$visible = WC_Helper_Product::create_simple_product();
+		update_post_meta( $visible->get_id(), '_wc_average_rating', '4.00' );
+		$visible->set_date_created( time() - HOUR_IN_SECONDS );
+		$visible->save();
+		$hidden = WC_Helper_Product::create_simple_product();
+		$hidden->set_catalog_visibility( 'hidden' );
+		$hidden->save();
+		update_post_meta( $hidden->get_id(), '_wc_average_rating', '5.00' );
+
+		$store = $this->healthy_store();
+		$json  = wp_json_encode(
+			array(
+				'@type' => 'Product',
+				'name'  => $visible->get_name(),
+			)
+		);
+		$store[ self::path( $visible->get_permalink() ) ] = array( 200, '<script type="application/ld+json">' . $json . '</script>' );
+
+		$this->assertFalse( $this->results( $store )['product_review_markup'] );
+	}
+
+	/**
+	 * @testdox Hidden reviewed products are skipped before the sample limit, so an older visible one is still read.
+	 */
+	public function test_review_markup_skips_a_run_of_hidden_products(): void {
+		update_option( 'woocommerce_enable_reviews', 'yes' );
+		update_option( 'woocommerce_enable_review_rating', 'yes' );
+		$visible = WC_Helper_Product::create_simple_product();
+		$visible->set_date_created( time() - DAY_IN_SECONDS );
+		$visible->save();
+		update_post_meta( $visible->get_id(), '_wc_average_rating', '4.00' );
+		for ( $i = 0; $i < 5; $i++ ) {
+			$hidden = WC_Helper_Product::create_simple_product();
+			$hidden->set_catalog_visibility( 'hidden' );
+			$hidden->save();
+			update_post_meta( $hidden->get_id(), '_wc_average_rating', '5.00' );
+		}
+
+		$store = $this->healthy_store();
+		$json  = wp_json_encode(
+			array(
+				'@type' => 'Product',
+				'name'  => $visible->get_name(),
+			)
+		);
+		$store[ self::path( $visible->get_permalink() ) ] = array( 200, '<script type="application/ld+json">' . $json . '</script>' );
+
+		$this->assertFalse( $this->results( $store )['product_review_markup'] );
+	}
+
+	/**
+	 * @testdox lastmod is read from the sitemaps robots.txt names and the default paths, or from the first sitemap an index lists; every candidate is tried.
+	 */
+	public function test_sitemap_lastmod_from_index(): void {
+		$child                    = home_url( '/products.xml' );
+		$store                    = $this->healthy_store();
+		$store['/wp-sitemap.xml'] = array( 200, "<sitemapindex><sitemap><loc>$child</loc></sitemap></sitemapindex>" );
+		$store['/products.xml']   = array( 200, '<urlset><url><loc>a</loc><lastmod>2026-01-01</lastmod></url></urlset>' );
+		$this->assertTrue( $this->results( $store )['sitemap_lastmod'] );
+
+		remove_all_filters( 'pre_http_request' );
+		$store['/wp-sitemap.xml'] = array( 200, '<sitemapindex><sitemap><loc><![CDATA[' . $child . ']]></loc></sitemap></sitemapindex>' );
+		$this->assertTrue( $this->results( $store )['sitemap_lastmod'], 'A CDATA child URL is still fetched' );
+
+		remove_all_filters( 'pre_http_request' );
+		$queried                  = home_url( '/products.xml?page=2&type=product' );
+		$store['/wp-sitemap.xml'] = array( 200, '<sitemapindex><sitemap><loc>' . str_replace( '&', '&amp;', $queried ) . '</loc></sitemap></sitemapindex>' );
+		unset( $store['/products.xml'] );
+		$store[ self::path( $queried ) ] = array( 200, '<urlset><url><loc>a</loc><lastmod>2026-01-01</lastmod></url></urlset>' );
+		$this->assertTrue( $this->results( $store )['sitemap_lastmod'], 'An escaped query string in a child URL is still fetched' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store['/wp-sitemap.xml'] = array( 200, "<sitemapindex><sitemap><loc>$child</loc></sitemap></sitemapindex>" );
+		$store['/products.xml']   = array( 200, '<urlset><url><loc>a</loc></url></urlset>' );
+		$this->assertFalse( $this->results( $store )['sitemap_lastmod'] );
+
+		remove_all_filters( 'pre_http_request' );
+		$store['/sitemap.xml'] = array( 200, '<urlset><url><loc>a</loc><lastmod>2026-01-01</lastmod></url></urlset>' );
+		$this->assertTrue( $this->results( $store )['sitemap_lastmod'], 'The listed sitemap has no dates, a default one has' );
+
+		remove_all_filters( 'pre_http_request' );
+		unset( $store['/sitemap.xml'] );
+		$store['/wp-sitemap.xml'] = array( 200, '<sitemapindex><sitemap><loc>https://cdn.example/products.xml</loc></sitemap><sitemap><loc>' . $child . '</loc></sitemap></sitemapindex>' );
+		$store['/products.xml']   = array( 200, '<urlset><url><loc>a</loc><lastmod>2026-01-01</lastmod></url></urlset>' );
+		$this->assertTrue( $this->results( $store )['sitemap_lastmod'], 'An off-host first child is skipped and the next child is read' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store['/wp-sitemap.xml'] = array( 200, '<sitemapindex><sitemap><loc>' . home_url( '/nested.xml' ) . '</loc></sitemap></sitemapindex>' );
+		$store['/nested.xml']     = array( 200, '<sitemapindex><sitemap><loc>' . $child . '</loc></sitemap></sitemapindex>' );
+		$this->assertTrue( $this->results( $store )['sitemap_lastmod'], 'A nested index is opened' );
+
+		remove_all_filters( 'pre_http_request' );
+		unset( $store['/nested.xml'], $store['/products.xml'] );
+		$store['/wp-sitemap.xml'] = array( 200, '<sitemapindex><sitemap><loc>https://cdn.example/products.xml</loc></sitemap></sitemapindex>' );
+		$this->assertFalse( $this->results( $store )['sitemap_lastmod'], 'A CDN-hosted child is skipped, not left unchecked' );
+	}
+
+	/**
+	 * @testdox sitemap_lastmod is couldn't check when the listed sitemap fails, or robots.txt fails and no default sitemap answers.
+	 */
+	public function test_sitemap_lastmod_unknown(): void {
+		$child                    = home_url( '/products.xml' );
+		$store                    = $this->healthy_store();
+		$store['/wp-sitemap.xml'] = array( 200, "<sitemapindex><sitemap><loc>$child</loc></sitemap></sitemapindex>" );
+		$store['/products.xml']   = array( 503, '' );
+		$this->assertNull( $this->results( $store )['sitemap_lastmod'], 'Listed sitemap fails' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store['/products.xml'] = array( 403, '' );
+		$this->assertNull( $this->results( $store )['sitemap_lastmod'], 'A blocked sitemap was not read' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store                = $this->healthy_store();
+		$store['/robots.txt'] = array( 403, '' );
+		$this->assertTrue( $this->results( $store )['sitemap_lastmod'], 'robots.txt fails, default sitemap has dates' );
+
+		remove_all_filters( 'pre_http_request' );
+		unset( $store['/wp-sitemap.xml'] );
+		$this->assertNull( $this->results( $store )['sitemap_lastmod'], 'robots.txt fails, no sitemap at the default paths' );
+	}
+
+	/**
+	 * @testdox The shop and a category page need a meta description. A stock archive without a canonical link does not fail that check.
+	 */
+	public function test_shop_and_category_pages(): void {
+		$shop = self::factory()->post->create(
+			array(
+				'post_type'   => 'page',
+				'post_status' => 'publish',
+				'post_name'   => 'shop',
+			)
+		);
+		update_option( 'woocommerce_shop_page_id', $shop );
+		$term = wp_insert_term( 'Mugs', 'product_cat' );
+		wp_set_object_terms( $this->product->get_id(), array( (int) $term['term_id'] ), 'product_cat' );
+		$this->product = wc_get_product( $this->product->get_id() );
+
+		$tagged            = static fn( string $url ): string => '<html><head><link rel="canonical" href="' . $url . '"><meta name="description" content="Mugs"></head></html>';
+		$store             = $this->healthy_store();
+		$path              = self::path( $this->product->get_permalink() );
+		$category          = (string) get_term_link( (int) $term['term_id'], 'product_cat' );
+		$store[ $path ][1] = str_replace( '<meta charset="UTF-8">', '<meta charset="UTF-8"><link rel="canonical" href="' . $this->product->get_permalink() . '"><meta name="description" content="A mug">', $store[ $path ][1] );
+		$store['/']        = array( 200, str_replace( '<meta charset="UTF-8">', '<meta charset="UTF-8"><meta name="description" content="Store">', $store['/'][1] ) );
+		$store[ self::path( (string) get_permalink( $shop ) ) ] = array( 200, '<html><head></head></html>' );
+		$store[ self::path( $category ) ]                       = array( 200, $tagged( $category ) );
+		$results = $this->results( $store );
+		$this->assertTrue( $results['canonical_url'], 'A shop page without a canonical link does not fail: WordPress does not print one on an archive' );
+		$this->assertFalse( $results['meta_description'], 'Shop page without a meta description' );
+
+		remove_all_filters( 'pre_http_request' );
+		$store[ self::path( (string) get_permalink( $shop ) ) ] = array( 200, $tagged( (string) get_permalink( $shop ) ) );
+		$results = $this->results( $store );
+		$this->assertTrue( $results['canonical_url'] );
+		$this->assertTrue( $results['meta_description'] );
+
+		remove_all_filters( 'pre_http_request' );
+		$store[ $path ][1] = str_replace( '<link rel="canonical" href="' . $this->product->get_permalink() . '">', '', $store[ $path ][1] );
+		$this->assertFalse( $this->results( $store )['canonical_url'], 'The product page is missing the canonical link WordPress prints' );
+	}
+}
diff --git a/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/ServedOutputChecksTest.php b/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/ServedOutputChecksTest.php
index 63f1a61432e..f77773cd393 100644
--- a/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/ServedOutputChecksTest.php
+++ b/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/ServedOutputChecksTest.php
@@ -4,6 +4,7 @@ declare( strict_types = 1 );
 namespace Automattic\WooCommerce\Tests\Internal\AgentReadiness;

 use Automattic\WooCommerce\Internal\AgentReadiness\StoreOutputChecks;
+use Automattic\WooCommerce\Internal\AgentReadiness\StoreResponses;
 use Automattic\WooCommerce\StoreApi\Utilities\Ucp\Utils as UcpUtils;
 use WC_Helper_Product;
 use WC_Unit_Test_Case;
@@ -196,6 +197,11 @@ class ServedOutputChecksTest extends WC_Unit_Test_Case {
 		$this->assertContains( '/llms.txt', $this->requested );
 		$this->assertTrue( $this->results()['open_graph_tags'], 'A slow link does not stop the other checks' );

+		$responses['/llms.txt'] = array( 200, "# Shop\n" . implode( '', array_map( static fn( int $i ): string => "- [Part $i](" . home_url( "/about/#part-$i" ) . ")\n", range( 1, 5 ) ) ) . '- [Old](' . home_url( '/old/' ) . ")\n" );
+		$responses['/old/']     = array( 404, '' );
+		$this->serve( $responses );
+		$this->assertFalse( $this->results()['llms_txt_links_resolve'], 'Links to anchors on one page are one link' );
+
 		$responses['/old/'] = array( 403, 'Blocked' );
 		$this->serve( $responses );
 		$this->assertNull( $this->results()['llms_txt_links_resolve'], 'A firewall refusing the store its own page is not a broken link' );
@@ -250,22 +256,49 @@ class ServedOutputChecksTest extends WC_Unit_Test_Case {
 	}

 	/**
-	 * @testdox When the home page times out, nothing else is loaded and every served check is couldn't check; with only the home page, the page checks read it alone.
+	 * @testdox A price with a currency symbol after it that ends in a period (10,00 kr.) is found in the page.
+	 */
+	public function test_price_with_symbol_ending_in_period(): void {
+		update_option( 'woocommerce_currency', 'DKK' );
+		update_option( 'woocommerce_currency_pos', 'right_space' );
+		update_option( 'woocommerce_price_decimal_sep', ',' );
+		update_option( 'woocommerce_price_thousand_sep', '.' );
+		$responses                          = $this->good_store();
+		$responses[ $this->product_path() ] = array( 200, self::page( '', '<h1>Blue &amp; Gold Mug</h1><p class="price">10,00&nbsp;kr.</p>' ) );
+		$this->serve( $responses );
+
+		$this->assertTrue( $this->results()['content_in_raw_html'] );
+	}
+
+	/**
+	 * @testdox When the home page times out, also after a redirect, nothing else is loaded and every served check is couldn't check. A product page that doesn't load leaves the page checks couldn't check; with no product, they read the home page alone.
 	 */
 	public function test_couldnt_check(): void {
 		$this->serve( array( '/' => null ) );
 		$this->assertSame( array_fill_keys( self::SERVED_CHECKS, null ), $this->results() );
 		$this->assertSame( array( '/' ), $this->requested, 'Nothing else is requested when the home page times out' );

+		$this->serve(
+			array(
+				'/'    => array( 301, '', array( 'location' => home_url( '/en/' ) ) ),
+				'/en/' => null,
+			)
+		);
+		$this->assertSame( array_fill_keys( self::SERVED_CHECKS, null ), $this->results() );
+		$this->assertSame( array( '/', '/en/' ), $this->requested, 'Nothing else is requested when the redirected home page times out' );
+
 		$this->serve( array( '/' => $this->good_store()['/'] ) );
 		$results = $this->results();
-		$this->assertTrue( $results['open_graph_tags'] );
+		$this->assertNull( $results['open_graph_tags'], 'The product page did not load' );
 		$this->assertNull( $results['canonical_url'] );
 		$this->assertNull( $results['content_in_raw_html'] );
+
+		$this->product->delete( true );
+		$this->assertTrue( $this->results()['open_graph_tags'], 'With no product, the home page alone' );
 	}

 	/**
-	 * @testdox With UCP on, the profile and catalog search checks read the served profile and POST to the endpoint it names.
+	 * @testdox With UCP on, the profile check reads the served profile, and the endpoint check POSTs to catalog search.
 	 */
 	public function test_ucp_checks(): void {
 		update_option( 'woocommerce_feature_ucp_enabled', 'yes' );
@@ -283,28 +316,48 @@ class ServedOutputChecksTest extends WC_Unit_Test_Case {
 				),
 			)
 		);
-		$search   = 'POST ' . $path . '/catalog/search';

-		$responses                     = $this->good_store();
-		$responses['/.well-known/ucp'] = array( 200, (string) $profile );
-		$responses[ $search ]          = array( 200, '{"ucp":{},"products":[]}' );
+		$search                         = $path . '/catalog/search';
+		$responses                      = $this->good_store();
+		$responses['/.well-known/ucp']  = array( 200, (string) $profile );
+		$responses[ $path ]             = array( 404, '' );
+		$responses[ 'POST ' . $search ] = array( 200, '{"ucp":{"status":"success"},"products":[]}' );
 		$this->serve( $responses );
 		$results = $this->results();
 		$this->assertTrue( $results['ucp_profile'] );
 		$this->assertTrue( $results['ucp_profile_version'] );
-		$this->assertTrue( $results['ucp_endpoints_live'] );
+		$this->assertTrue( $results['ucp_endpoints_live'], 'Catalog search answers even when a GET of the endpoint base does not' );
+		$this->assertContains( 'POST ' . $search, $this->requested );
+
+		$responses[ 'POST ' . $search ] = array( 400, '{"ucp":{"status":"error"},"messages":[{"code":"VALIDATION_ERROR","content":"A query or at least one supported filter is required."}]}' );
+		$this->serve( $responses );
+		$this->assertTrue( $this->results()['ucp_endpoints_live'], 'An empty search is a JSON 400, which means the route answered' );
+
+		$responses[ 'POST ' . $search ] = array( 400, '<html>Bad request</html>' );
+		$this->serve( $responses );
+		$this->assertFalse( $this->results()['ucp_endpoints_live'], 'A 400 page is not the endpoint' );

 		$responses['/.well-known/ucp'] = array( 200, (string) str_replace( UcpUtils::VERSION, '2025-01-01', (string) $profile ) );
 		$this->serve( $responses );
 		$this->assertFalse( $this->results()['ucp_profile_version'], 'A profile for another UCP version is likely another plugin\'s' );

-		$responses['/.well-known/ucp'] = array( 404, '' );
-		$responses[ $search ]          = array( 403, '<html>Blocked</html>' );
+		$responses['/.well-known/ucp']  = array( 404, '' );
+		$responses[ 'POST ' . $search ] = array( 403, '<html>Blocked</html>' );
 		$this->serve( $responses );
 		$results = $this->results();
 		$this->assertFalse( $results['ucp_profile'] );
 		$this->assertNull( $results['ucp_profile_version'], 'No profile is reported by ucp_profile alone' );
-		$this->assertFalse( $results['ucp_endpoints_live'], 'Without a profile, WooCommerce\'s endpoint is tried' );
+		$this->assertFalse( $results['ucp_endpoints_live'], 'Without a profile, WooCommerce\'s catalog search is tried' );
+		$this->assertContains( 'POST ' . $search, $this->requested );
+
+		$responses[ $path ]             = array( 200, '{"namespace":"wc/ucp/v1","routes":{}}' );
+		$responses[ 'POST ' . $search ] = array( 404, '' );
+		$this->serve( $responses );
+		$this->assertFalse( $this->results()['ucp_endpoints_live'], 'A JSON index is not catalog search' );
+
+		$responses[ 'POST ' . $search ] = array( 200, '<html>Checking your browser</html>' );
+		$this->serve( $responses );
+		$this->assertFalse( $this->results()['ucp_endpoints_live'], 'A challenge page is not the endpoint' );
 	}

 	/**
@@ -361,4 +414,71 @@ class ServedOutputChecksTest extends WC_Unit_Test_Case {
 			$this->assertContains( $check['group'], array( 'access', 'find', 'understand', 'buy' ), $check['id'] );
 		}
 	}
+
+	/**
+	 * @testdox The pending product checks read the variants of a ProductGroup, and don't fail a variable product, which WooCommerce gives no buy action, or a product that doesn't ship.
+	 */
+	public function test_pending_product_detectors_read_variants(): void {
+		$offer_has  = new \ReflectionMethod( StoreOutputChecks::class, 'offer_has' );
+		$buy_action = new \ReflectionMethod( StoreOutputChecks::class, 'has_buy_action' );
+		$ships      = new \ReflectionMethod( StoreOutputChecks::class, 'ships' );
+		$offer_has->setAccessible( true );
+		$buy_action->setAccessible( true );
+		$ships->setAccessible( true );
+		$group       = array(
+			'@type'      => 'ProductGroup',
+			'hasVariant' => array(
+				array(
+					'@type'           => 'Product',
+					'offers'          => array(
+						'@type'           => 'Offer',
+						'shippingDetails' => array( '@type' => 'OfferShippingDetails' ),
+					),
+					'potentialAction' => array( '@type' => 'BuyAction' ),
+				),
+			),
+		);
+		$empty_group = array(
+			'@type'      => 'ProductGroup',
+			'hasVariant' => array( array( '@type' => 'Product' ) ),
+		);
+		$variable    = WC_Helper_Product::create_variation_product();
+
+		$this->assertTrue( $offer_has->invoke( null, array( $group ), 'shippingDetails' ), 'Shipping details on a variant\'s offer' );
+		$this->assertFalse( $offer_has->invoke( null, array( $group ), 'hasMerchantReturnPolicy' ) );
+		$this->assertTrue( $buy_action->invoke( null, array( $group ), $variable ), 'A BuyAction on a variant' );
+		$this->assertNull( $buy_action->invoke( null, array( $empty_group ), $variable ), 'A variable product without one' );
+		$this->assertFalse( $buy_action->invoke( null, array( $empty_group ), $this->product ), 'A simple product without one' );
+
+		$this->assertTrue( $ships->invoke( null, new StoreResponses( true ) ) );
+		$this->product->set_virtual( true );
+		$this->product->save();
+		$variable->delete( true );
+		$this->assertFalse( $ships->invoke( null, new StoreResponses( true ) ), 'A virtual product has no shipping details to give' );
+	}
+
+	/**
+	 * @testdox When something strips WooCommerce's Open Graph tags from the product page, the check flags a likely conflict, names the page but no plugin, even with an SEO plugin active; with WooCommerce's tags turned off, the check isn't run.
+	 */
+	public function test_open_graph_conflict(): void {
+		$responses                          = $this->good_store();
+		$responses[ $this->product_path() ] = array( 200, self::page( '', '<h1>Blue &amp; Gold Mug</h1>', false ) );
+		$this->serve( $responses );
+		update_option( 'active_plugins', array( 'wordpress-seo/wp-seo.php', 'hello.php' ) );
+
+		$checks = array_column( $this->sut->all(), null, 'id' );
+
+		$this->assertFalse( $checks['open_graph_from_core']['ok'] );
+		$this->assertTrue( $checks['open_graph_from_core']['conflict'] );
+		$this->assertSame( (string) $this->product->get_permalink(), $checks['open_graph_from_core']['seen_at'] );
+		$this->assertArrayNotHasKey( 'plugins', $checks['open_graph_from_core'], 'No plugin is named: a list of plugins goes stale' );
+		$this->assertSame( '', $checks['open_graph_tags']['seen_at'], 'Checks that are not conflicts carry no address' );
+
+		$this->serve( $this->good_store() );
+		$this->assertTrue( array_column( $this->sut->all(), 'ok', 'id' )['open_graph_from_core'] );
+
+		add_filter( 'woocommerce_enable_open_graph', '__return_false' );
+		$this->assertArrayNotHasKey( 'open_graph_from_core', array_column( $this->sut->all(), 'ok', 'id' ) );
+		remove_filter( 'woocommerce_enable_open_graph', '__return_false' );
+	}
 }
diff --git a/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/StoreOutputChecksTest.php b/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/StoreOutputChecksTest.php
index d418b70517a..369a50eb31e 100644
--- a/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/StoreOutputChecksTest.php
+++ b/plugins/woocommerce/tests/php/src/Internal/AgentReadiness/StoreOutputChecksTest.php
@@ -3,6 +3,7 @@ declare( strict_types = 1 );

 namespace Automattic\WooCommerce\Tests\Internal\AgentReadiness;

+use Automattic\WooCommerce\Internal\AgentReadiness\JsonLd;
 use Automattic\WooCommerce\Internal\AgentReadiness\StoreOutputChecks;
 use WC_Helper_Product;
 use WC_Structured_Data;
@@ -523,6 +524,224 @@ class StoreOutputChecksTest extends WC_Unit_Test_Case {
 		$this->assertFalse( $conflicts['sitemap_lists_products'] );
 	}

+	/**
+	 * Results and conflict flags of the GTIN and brand checks after serving one product page.
+	 *
+	 * @param \WC_Product              $product Product whose page is served.
+	 * @param array<int, array|string> $blocks  JSON-LD blocks on the page.
+	 * @return array<string, bool|string|null>
+	 */
+	private function served_identifiers( \WC_Product $product, array $blocks ): array {
+		remove_all_filters( 'pre_http_request' );
+		$this->serve( array( self::path_of( $product ) => array( 200, self::page_with( $blocks ) ) ) );
+		$checks = array_column( $this->sut->all(), null, 'id' );
+		return array(
+			'gtin'           => $checks['product_gtin_jsonld']['ok'],
+			'gtin_conflict'  => $checks['product_gtin_jsonld']['conflict'],
+			'brand'          => $checks['product_brand_jsonld']['ok'],
+			'brand_conflict' => $checks['product_brand_jsonld']['conflict'],
+			'brand_seen_at'  => $checks['product_brand_jsonld']['seen_at'],
+		);
+	}
+
+	/**
+	 * @testdox The GTIN check passes when the page gives a valid GTIN from any source, and flags a likely conflict only when the product's own valid GTIN is missing or replaced.
+	 */
+	public function test_served_gtin(): void {
+		$product = WC_Helper_Product::create_simple_product();
+		$product->set_global_unique_id( '4006381333931' );
+		$product->save();
+		$plugin = array(
+			'@type' => 'Product',
+			'name'  => $product->get_name(),
+		);
+
+		$this->assertTrue( $this->served_identifiers( $product, array( self::core_product_jsonld( $product ) ) )['gtin'], 'WooCommerce prints the GTIN' );
+
+		$result = $this->served_identifiers( $product, array( $plugin ) );
+		$this->assertFalse( $result['gtin'], 'A plugin replaced the JSON-LD without the GTIN' );
+		$this->assertTrue( $result['gtin_conflict'] );
+
+		$this->assertFalse( $this->served_identifiers( $product, array( $plugin + array( 'gtin13' => '4006381333932' ) ) )['gtin'], 'Another, invalid GTIN' );
+		$this->assertTrue( $this->served_identifiers( $product, array( $plugin + array( 'gtin13' => '4006381-333931' ) ) )['gtin'], 'Formatting alone is no conflict' );
+		$this->assertTrue( $this->served_identifiers( $product, array( $plugin + array( 'offers' => array( 'gtin' => 4006381333931 ) ) ) )['gtin'], 'A GTIN on the offer, as a number' );
+		$this->assertTrue( $this->served_identifiers( $product, array( $plugin + array( 'gtin13' => array( '4006381333931' ) ) ) )['gtin'], 'A GTIN given as a list' );
+		$upsell = array(
+			'@type'  => 'Product',
+			'name'   => 'Another product',
+			'gtin13' => '9780306406157',
+		);
+		$this->assertFalse( $this->served_identifiers( $product, array( $plugin, $upsell ) )['gtin'], 'Another product\'s GTIN on the page doesn\'t count' );
+		$this->assertFalse( $this->served_identifiers( $product, array( $upsell ) )['gtin'], 'An upsell alone is not this product' );
+		$permalink = (string) $product->get_permalink();
+		$flipped   = str_starts_with( $permalink, 'https:' ) ? 'http:' . substr( $permalink, strlen( 'https:' ) ) : 'https:' . substr( $permalink, strlen( 'http:' ) );
+		$this->assertTrue(
+			$this->served_identifiers(
+				$product,
+				array(
+					array(
+						'@type'  => 'Product',
+						'name'   => 'Sold as something else',
+						'url'    => $flipped . '#product',
+						'gtin13' => '4006381333931',
+					),
+				)
+			)['gtin'],
+			'A different name still counts when the url is this product'
+		);
+		$this->assertTrue(
+			$this->served_identifiers(
+				$product,
+				array(
+					array(
+						'@type'  => 'Product',
+						'name'   => 'Sold as something else',
+						'@id'    => $permalink . '#product',
+						'gtin13' => '4006381333931',
+					),
+				)
+			)['gtin'],
+			'An @id of this product counts too'
+		);
+		$group = $product->get_permalink() . '#group';
+		$this->assertTrue(
+			$this->served_identifiers(
+				$product,
+				array(
+					array(
+						'@type' => 'ProductGroup',
+						'name'  => $product->get_name(),
+						'@id'   => $group,
+					),
+					array(
+						'@type'       => 'Product',
+						'name'        => 'Red',
+						'isVariantOf' => array( '@id' => $group ),
+						'gtin13'      => '4006381333931',
+					),
+				)
+			)['gtin'],
+			'A variant linked with isVariantOf counts'
+		);
+		$this->assertTrue(
+			$this->served_identifiers(
+				$product,
+				array(
+					array(
+						'@type'      => 'ProductGroup',
+						'name'       => $product->get_name(),
+						'hasVariant' => array( array( '@id' => '#red' ) ),
+					),
+					array(
+						'@type'  => 'Product',
+						'name'   => 'Mug - Red',
+						'@id'    => '#red',
+						'gtin13' => '4006381333931',
+					),
+				)
+			)['gtin'],
+			'A variant named only by hasVariant @id counts'
+		);
+
+		$product->set_global_unique_id( '' );
+		$product->save();
+		$this->assertTrue( $this->served_identifiers( $product, array( $plugin + array( 'gtin' => '4006381333931' ) ) )['gtin'], 'A plugin provides the GTIN the product lacks' );
+		$this->assertNull( $this->served_identifiers( $product, array( $plugin ) )['gtin'], 'Neither has one: missing_gtin reports it' );
+		$this->assertNull( $this->served_identifiers( $product, array( $plugin + array( 'gtin' => '123' ) ) )['gtin'], 'An invalid GTIN from elsewhere isn\'t a conflict when WooCommerce has none to print' );
+
+		$product->set_global_unique_id( '4006381333932' );
+		$product->save();
+		$this->assertNull( $this->served_identifiers( $product, array( self::core_product_jsonld( $product ) ) )['gtin'], 'The product\'s own invalid GTIN: invalid_gtin reports it' );
+
+		$product->set_virtual( true );
+		$product->save();
+		$this->assertNull( $this->served_identifiers( $product, array( $plugin ) )['gtin'], 'A virtual product needs no GTIN' );
+	}
+
+	/**
+	 * @testdox The brand check passes when the page gives a brand from any source, and fails only when the product has a WooCommerce brand the page doesn't give.
+	 */
+	public function test_served_brand(): void {
+		$product = WC_Helper_Product::create_simple_product();
+		$plugin  = array(
+			'@type' => 'Product',
+			'name'  => $product->get_name(),
+		);
+
+		$this->assertNull( $this->served_identifiers( $product, array( $plugin ) )['brand'], 'No brand anywhere: missing_brand reports it' );
+		$this->assertTrue( $this->served_identifiers( $product, array( $plugin + array( 'brand' => 'Acme' ) ) )['brand'], 'A plugin provides the brand, as text' );
+
+		$attribute = new \WC_Product_Attribute();
+		$attribute->set_name( 'Brand' );
+		$attribute->set_options( array( 'Acme' ) );
+		$product->set_attributes( array( $attribute ) );
+		$product->save();
+		$this->assertNull( $this->served_identifiers( $product, array( $plugin ) )['brand'], 'WooCommerce doesn\'t print a brand attribute, so it isn\'t a conflict' );
+
+		wp_set_object_terms( $product->get_id(), 'Acme', 'product_brand' );
+		$result = $this->served_identifiers( $product, array( $plugin ) );
+		$this->assertFalse( $result['brand'], 'The WooCommerce brand is missing from the page' );
+		$this->assertTrue( $result['brand_conflict'] );
+		$this->assertSame( (string) $product->get_permalink(), $result['brand_seen_at'] );
+		$upsell = array(
+			'@type' => 'Product',
+			'name'  => 'Another product',
+			'brand' => 'Other',
+		);
+		$this->assertFalse( $this->served_identifiers( $product, array( $plugin, $upsell ) )['brand'], 'Another product\'s brand on the page doesn\'t count' );
+		$this->assertTrue( $this->served_identifiers( $product, array( self::core_product_jsonld( wc_get_product( $product->get_id() ) ) ) )['brand'], 'WooCommerce prints its brand' );
+		$this->assertTrue(
+			$this->served_identifiers(
+				$product,
+				array(
+					$plugin + array(
+						'brand' => array(
+							array(
+								'@type' => 'Brand',
+								'name'  => 'Acme',
+							),
+						),
+					),
+				)
+			)['brand'],
+			'A list of Brand items'
+		);
+		$this->assertFalse( $this->served_identifiers( $product, array( $plugin + array( 'brand' => array( 'name' => ' ' ) ) ) )['brand'], 'An empty brand name' );
+	}
+
+	/**
+	 * @testdox A ProductGroup whose offers sit on its variants passes the product checks. One whose variants have no offer fails the required fields and offer checks.
+	 */
+	public function test_product_group_offers_on_variants(): void {
+		$product = WC_Helper_Product::create_simple_product();
+		$path    = self::path_of( $product );
+		$group   = array(
+			'@context'   => 'https://schema.org',
+			'@type'      => 'ProductGroup',
+			'name'       => 'Dummy Product',
+			'image'      => 'https://example.org/image.jpg',
+			'variesBy'   => 'https://schema.org/color',
+			'hasVariant' => array(
+				array(
+					'@type'  => 'Product',
+					'name'   => 'Dummy Product - Red',
+					'offers' => array(
+						'@type'        => 'Offer',
+						'price'        => '10.00',
+						'availability' => 'https://schema.org/InStock',
+					),
+				),
+			),
+		);
+		$this->serve( array( $path => array( 200, self::page_with( array( $group ) ) ) ) );
+		$this->assertSame( array( true, true, true ), $this->product_results() );
+
+		remove_all_filters( 'pre_http_request' );
+		unset( $group['hasVariant'][0]['offers'] );
+		$this->serve( array( $path => array( 200, self::page_with( array( $group ) ) ) ) );
+		$this->assertSame( array( true, false, false ), $this->product_results() );
+	}
+
 	/**
 	 * @testdox A product page without Product JSON-LD fails only the presence check. One without a price fails only the offer check. A price written with a currency still counts.
 	 */
@@ -549,6 +768,29 @@ class StoreOutputChecksTest extends WC_Unit_Test_Case {
 		$no_price['offers']['price'] = '10.00 USD';
 		$this->serve( array( $path => array( 200, self::page_with( array( $no_price ) ) ) ) );
 		$this->assertSame( array( true, true, true ), $this->product_results(), 'A price with a currency code counts' );
+
+		foreach ( array( '$10.00', '€10', '10,00 kr.', "10\u{202F}000.00", 'R$ 10,00', 'US$10', 'S/. 10', 'EUR 10,-' ) as $text ) {
+			remove_all_filters( 'pre_http_request' );
+			$no_price['offers']['price'] = $text;
+			$this->serve( array( $path => array( 200, self::page_with( array( $no_price ) ) ) ) );
+			$this->assertSame( array( true, true, true ), $this->product_results(), "A price with a symbol or spaces counts: $text" );
+		}
+
+		foreach ( array( 'call 555', 'Free 2 day' ) as $text ) {
+			remove_all_filters( 'pre_http_request' );
+			$no_price['offers']['price'] = $text;
+			$this->serve( array( $path => array( 200, self::page_with( array( $no_price ) ) ) ) );
+			$this->assertSame( array( true, true, false ), $this->product_results(), "Text with a number in it is not a price: $text" );
+		}
+	}
+
+	/**
+	 * @testdox JSON-LD is read from a script whose type attribute names it, also when another attribute holds a >; a data-type attribute does not count.
+	 */
+	public function test_jsonld_script_tag(): void {
+		$block = '{"@type":"Product","name":"Mug"}';
+		$this->assertCount( 1, JsonLd::items( '<script data-x="a>b" type="application/ld+json">' . $block . '</script>', 'Product' ) );
+		$this->assertCount( 0, JsonLd::items( '<script data-type="application/ld+json">' . $block . '</script>', 'Product' ) );
 	}

 	/**
@@ -593,15 +835,15 @@ class StoreOutputChecksTest extends WC_Unit_Test_Case {
 		$open->set_date_created( time() - HOUR_IN_SECONDS );
 		$open->set_image_id( self::factory()->attachment->create_object( array( 'file' => 'image.jpg' ) ) );
 		$open->save();
-		$locked = WC_Helper_Product::create_simple_product();
-		$locked->set_post_password( 'secret' );
-		$locked->save();
-		$this->serve(
-			array(
-				self::path_of( $open )   => array( 200, self::page_with( array( self::core_product_jsonld( $open ) ) ) ),
-				self::path_of( $locked ) => array( 200, self::page_with( array() ) ),
-			)
-		);
+		$responses = array( self::path_of( $open ) => array( 200, self::page_with( array( self::core_product_jsonld( $open ) ) ) ) );
+		// More locked products than the five newest that are looked at.
+		for ( $i = 0; $i < 6; $i++ ) {
+			$locked = WC_Helper_Product::create_simple_product();
+			$locked->set_post_password( 'secret' );
+			$locked->save();
+			$responses[ self::path_of( $locked ) ] = array( 200, self::page_with( array() ) );
+		}
+		$this->serve( $responses );

 		$this->assertSame( array( true, true, true ), $this->product_results() );
 	}