From 7c8e03b551b695ff4c3f77865693aa0f34c4df1c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 9 Sep 2026 11:46:22 +0000
Subject: [PATCH 1/7] Fix e2e drift: pin wp-env versions and update AQL locator

Two e2e tests in exclude-with-post-in.spec.js began failing on main with no
code change, timing out in editor setup waiting for the "Posts to Include"
combobox.

Cause: Advanced Query Loop 5.0.0 (released 2026-08-31), which .wp-env.json
pulled in via the unversioned advanced-query-loop.zip. That release moved the
post parameter controls into a ToolsPanel, and "Include posts" is not one of
the items shown by default, so the field is not rendered at all until it is
enabled from the panel's options menu.

WordPress core was ruled out as the cause: FormTokenField and its token-input
(which renders role="combobox") are byte-identical between the 6.9 and 6.9.7
builds of wp-includes/js/dist/components.js, and still emit role="combobox".

Changes:

- Reveal the field via the "AQL: Post options" menu before using it, matching
  the pattern AQL uses in its own e2e suite, and locate it by label rather
  than by FormTokenField's implicit ARIA role, which is an upstream
  implementation detail.

- Pin core to the exact tag 6.9.7 rather than the floating #6.9 branch, and
  pin Advanced Query Loop to 5.0.0. Floating refs let an upstream release
  break CI with no change here, and made re-running an old green commit
  depend on the day it ran.

- Add a scheduled "E2E (latest upstream)" workflow that reuses the Playwright
  job with those pins overridden to latest, giving early warning of the next
  such break. It never runs on pull requests, so it cannot block a merge; on
  failure it opens or comments on a single rolling issue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Uc1T67ac4VvePFBhENPbki
---
 .github/workflows/e2e-latest.yml       | 68 ++++++++++++++++++++++++++
 .github/workflows/playwright-tests.yml | 27 ++++++++++
 .gitignore                             |  1 +
 .wp-env.json                           |  4 +-
 CLAUDE.md                              |  6 ++-
 tests/e2e/exclude-with-post-in.spec.js | 54 +++++++++++++++-----
 6 files changed, 146 insertions(+), 14 deletions(-)
 create mode 100644 .github/workflows/e2e-latest.yml

diff --git a/.github/workflows/e2e-latest.yml b/.github/workflows/e2e-latest.yml
new file mode 100644
index 0000000..52aec6e
--- /dev/null
+++ b/.github/workflows/e2e-latest.yml
@@ -0,0 +1,68 @@
+name: E2E (latest upstream)
+
+# Early warning for upstream drift.
+#
+# .wp-env.json pins WordPress core and Advanced Query Loop to exact versions so
+# that PR CI is reproducible and re-running an old green commit stays green.
+# The trade-off is that a breaking upstream release is invisible until someone
+# bumps a pin. This workflow runs the same suite against the latest releases on
+# a schedule, so we find out on our own time instead of mid-PR.
+#
+# It never runs on pull requests, so a failure here cannot block a merge.
+
+on:
+    schedule:
+        # 05:00 UTC every Monday.
+        - cron: '0 5 * * 1'
+    workflow_dispatch:
+
+concurrency:
+    group: ${{ github.workflow }}
+    cancel-in-progress: true
+
+jobs:
+    e2e:
+        name: Playwright
+        permissions:
+            contents: read
+            pull-requests: write
+        uses: ./.github/workflows/playwright-tests.yml
+        with:
+            unpinned: true
+
+    report:
+        name: Report drift
+        needs: e2e
+        if: failure() && github.event_name == 'schedule'
+        runs-on: ubuntu-latest
+        permissions:
+            contents: read
+            issues: write
+        steps:
+            - name: Open or update the drift issue
+              env:
+                  GH_TOKEN: ${{ github.token }}
+                  GH_REPO: ${{ github.repository }}
+                  RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+              run: |
+                  set -euo pipefail
+
+                  title='E2E suite fails against latest WordPress / Advanced Query Loop'
+                  body=$(printf '%s\n' \
+                    'The scheduled `E2E (latest upstream)` run failed.' \
+                    '' \
+                    'The suite passes against the versions pinned in `.wp-env.json` but fails' \
+                    'against the latest WordPress core and Advanced Query Loop releases, so' \
+                    'bumping those pins will break PR CI until the suite is updated.' \
+                    '' \
+                    "Failing run: ${RUN_URL}")
+
+                  # One rolling issue rather than one per week.
+                  existing=$(gh issue list --state open --search "$title in:title" \
+                    --json number --jq '.[0].number // empty')
+
+                  if [ -n "$existing" ]; then
+                    gh issue comment "$existing" --body "$body"
+                  else
+                    gh issue create --title "$title" --body "$body"
+                  fi
diff --git a/.github/workflows/playwright-tests.yml b/.github/workflows/playwright-tests.yml
index 3f724c5..4ca44bd 100644
--- a/.github/workflows/playwright-tests.yml
+++ b/.github/workflows/playwright-tests.yml
@@ -5,6 +5,16 @@ on:
         branches: [main, master, develop]
     pull_request:
         branches: [main, master, develop]
+    # Allows the scheduled `E2E (latest upstream)` workflow to reuse this job
+    # against unpinned WordPress core and Advanced Query Loop versions.
+    workflow_call:
+        inputs:
+            unpinned:
+                description: >-
+                    Ignore the versions pinned in .wp-env.json and run against
+                    the latest WordPress core and Advanced Query Loop releases.
+                type: boolean
+                default: false
 
 jobs:
     test:
@@ -33,6 +43,23 @@ jobs:
             - name: Install Playwright Browsers
               run: npx playwright install --with-deps chromium
 
+            # .wp-env.json pins core and Advanced Query Loop to exact versions so
+            # that re-running an old green commit stays green. This override
+            # deliberately un-pins them for the scheduled early-warning run.
+            - name: Un-pin upstream versions
+              if: inputs.unpinned
+              run: |
+                  cat > .wp-env.override.json <<'JSON'
+                  {
+                  	"core": null,
+                  	"plugins": [
+                  		".",
+                  		"https://downloads.wordpress.org/plugin/advanced-query-loop.zip"
+                  	]
+                  }
+                  JSON
+                  cat .wp-env.override.json
+
             - name: Start WordPress environment
               run: npm run wp-env start
 
diff --git a/.gitignore b/.gitignore
index cd284f9..de68df9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -36,3 +36,4 @@ playwright/.cache/
 /blob-report/
 /playwright/.cache/
 /playwright/.auth/
+.wp-env.override.json
diff --git a/.wp-env.json b/.wp-env.json
index 50d82a1..68e6cbb 100644
--- a/.wp-env.json
+++ b/.wp-env.json
@@ -1,8 +1,8 @@
 {
-	"core": "WordPress/WordPress#6.9",
+	"core": "WordPress/WordPress#6.9.7",
 	"plugins": [
 		".",
-		"https://downloads.wordpress.org/plugin/advanced-query-loop.zip"
+		"https://downloads.wordpress.org/plugin/advanced-query-loop.5.0.0.zip"
 	],
 	"themes": [ "WordPress/twentytwentyfour", "WordPress/twentytwentyfive" ],
 	"mappings": {
diff --git a/CLAUDE.md b/CLAUDE.md
index 6c49285..f23850d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -118,7 +118,11 @@ The plugin provides a PHP API for registering custom query presets that can be s
 
 ## Testing Environment
 
-Tests use `@wordpress/env` with WordPress 6.9, configured in `.wp-env.json`. The environment includes TwentyTwentyFour and TwentyTwentyFive themes, and the Advanced Query Loop plugin. Tests run on port 8889 and use Playwright with `@wordpress/e2e-test-utils-playwright`.
+Tests use `@wordpress/env`, configured in `.wp-env.json`. The environment includes TwentyTwentyFour and TwentyTwentyFive themes, and the Advanced Query Loop plugin. Tests run on port 8889 and use Playwright with `@wordpress/e2e-test-utils-playwright`.
+
+**Upstream versions are pinned deliberately.** `core` is pinned to an exact tag (`WordPress/WordPress#6.9.7`, not the `#6.9` branch) and Advanced Query Loop to an exact release zip. Floating refs let an upstream release break CI with no change in this repo, and make re-running an old green commit depend on the day it runs. When bumping a pin, expect to update any test that drives third-party UI.
+
+The scheduled `E2E (latest upstream)` workflow (`.github/workflows/e2e-latest.yml`) reuses the same Playwright job with those pins overridden to latest, so upstream drift shows up on a schedule instead of mid-PR. It never runs on pull requests, so it cannot block a merge; on failure it opens or comments on a single rolling issue.
 
 ## Important Implementation Notes
 
diff --git a/tests/e2e/exclude-with-post-in.spec.js b/tests/e2e/exclude-with-post-in.spec.js
index 80ea51a..11d04d5 100644
--- a/tests/e2e/exclude-with-post-in.spec.js
+++ b/tests/e2e/exclude-with-post-in.spec.js
@@ -8,6 +8,36 @@
  */
 const { test, expect } = require( './fixtures' );
 
+/**
+ * Reveals Advanced Query Loop's "Posts to Include" field.
+ *
+ * Since AQL 5.0.0 the post parameter controls live in a ToolsPanel, and
+ * "Include posts" is not one of the items shown by default — the field is only
+ * rendered once it has been enabled from that panel's options menu.
+ *
+ * @param {import('@playwright/test').Page} page Playwright page object.
+ */
+const revealPostsToIncludeField = async ( page ) => {
+	await page.getByRole( 'button', { name: 'AQL: Post options' } ).click();
+	await page
+		.getByRole( 'menuitemcheckbox', { name: 'Include posts' } )
+		.click();
+	await page.keyboard.press( 'Escape' );
+};
+
+/**
+ * Locates Advanced Query Loop's "Posts to Include" field.
+ *
+ * Matched by its label rather than by an implicit ARIA role: the role comes
+ * from @wordpress/components' FormTokenField and is an upstream implementation
+ * detail, whereas the label is AQL's own user-facing string.
+ *
+ * @param {import('@playwright/test').Page} page Playwright page object.
+ * @return {import('@playwright/test').Locator} The "Posts to Include" input.
+ */
+const postsToIncludeField = ( page ) =>
+	page.getByLabel( 'Posts to Include', { exact: true } );
+
 test.describe( 'Exclude Displayed Posts with post__in', () => {
 	test( 'should exclude displayed posts even when post__in is set via Advanced Query Loop', async ( {
 		page,
@@ -86,20 +116,23 @@ test.describe( 'Exclude Displayed Posts with post__in', () => {
 			.click();
 
 		// Selecting the pattern leaves a child block focused; re-select the
-		// AQL root block so its sidebar settings (including the Posts
-		// combobox) are shown.
+		// AQL root block so its sidebar settings (including the "AQL: Post"
+		// panel) are shown.
 		await blockEditor.selectBlock.byName( 'core/query', 0 );
 		// Check if we need to set this to a custom loop, WP 6.9 does not default to custom.
 		await blockEditor.queryBlock.setAsCustom();
 
 		// Set the posts to include - AQL requires typing to search; no posts shown until input has text.
+		await revealPostsToIncludeField( page );
+		await postsToIncludeField( page ).click();
+		await page.keyboard.type( 'Post 23' );
 		await page
-			.getByRole( 'combobox', { name: 'Posts to Include' } )
+			.getByRole( 'option', { name: 'Post 23', exact: true } )
 			.click();
-		await page.keyboard.type( 'Post 23' );
-		await page.getByRole( 'option', { name: 'Post 23', exact: true } ).click();
 		await page.keyboard.type( 'Post 21' );
-		await page.getByRole( 'option', { name: 'Post 21', exact: true } ).click();
+		await page
+			.getByRole( 'option', { name: 'Post 21', exact: true } )
+			.click();
 
 		// Get post titles from first query
 		const canvas = page
@@ -273,15 +306,14 @@ test.describe( 'Exclude Displayed Posts with post__in', () => {
 
 		await editor.openDocumentSettingsSidebar();
 		// Selecting the pattern leaves a child block focused; re-select the
-		// AQL root block so its sidebar settings (including the Posts
-		// combobox) are shown.
+		// AQL root block so its sidebar settings (including the "AQL: Post"
+		// panel) are shown.
 		await blockEditor.selectBlock.byName( 'core/query', 0 );
 		await blockEditor.queryBlock.setAsCustom();
 
 		// Set the posts to include - AQL requires typing to search; no posts shown until input has text.
-		await page
-			.getByRole( 'combobox', { name: 'Posts to Include' } )
-			.click();
+		await revealPostsToIncludeField( page );
+		await postsToIncludeField( page ).click();
 		for ( const postName of [
 			'Post 23',
 			'Post 21',

From 40e213c7220191c5d4d68534771a42f528715cc7 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 9 Sep 2026 12:27:01 +0000
Subject: [PATCH 2/7] CI: test across WordPress 6.9, 7.0, 7.1 and nightly
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

WordPress is now on 7.1, so the suite only exercising a single core version
leaves both the current release and the next one untested.

Replace the single Playwright job with a matrix. Core is still pinned per lane
to an exact tag rather than a branch, so re-running an old commit resolves to
the same WordPress:

  6.9      WordPress/WordPress#6.9.7   blocking
  7.0      WordPress/WordPress#7.0.4   blocking
  7.1      WordPress/WordPress#7.1     blocking
  nightly  WordPress/WordPress#master  non-blocking

The nightly lane deliberately tracks trunk for early warning. It never fails
its job, so upstream breakage cannot block a merge; a failure surfaces as a
warning annotation and a job summary instead.

Lanes are resolved as JSON in a small `lanes` job so a caller can narrow the
matrix without duplicating the test job. Core is selected per lane with
WP_ENV_CORE, which takes precedence over .wp-env.json for both the dev and
tests environments, so .wp-env.json now only carries the local development
default (bumped to 7.1).

An aggregate job keeps the id `test` so the existing required status check
still resolves — the per-version lanes publish names branch protection does
not know about. Artifact names and Playwright report tags are per lane, since
upload-artifact v4 rejects duplicate names and the report comment would
otherwise overwrite itself.

The scheduled workflow becomes the Advanced Query Loop canary only, since the
nightly lane now covers core trunk on every push. It runs one pinned-core lane
with AQL un-pinned.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Uc1T67ac4VvePFBhENPbki
---
 .github/workflows/e2e-latest.yml       |  31 ++++---
 .github/workflows/playwright-tests.yml | 119 +++++++++++++++++++++----
 .wp-env.json                           |   2 +-
 CLAUDE.md                              |  23 ++++-
 4 files changed, 143 insertions(+), 32 deletions(-)

diff --git a/.github/workflows/e2e-latest.yml b/.github/workflows/e2e-latest.yml
index 52aec6e..a8f375a 100644
--- a/.github/workflows/e2e-latest.yml
+++ b/.github/workflows/e2e-latest.yml
@@ -1,12 +1,16 @@
-name: E2E (latest upstream)
+name: E2E (latest AQL)
 
-# Early warning for upstream drift.
+# Early warning for third-party plugin drift.
 #
-# .wp-env.json pins WordPress core and Advanced Query Loop to exact versions so
-# that PR CI is reproducible and re-running an old green commit stays green.
-# The trade-off is that a breaking upstream release is invisible until someone
-# bumps a pin. This workflow runs the same suite against the latest releases on
-# a schedule, so we find out on our own time instead of mid-PR.
+# .wp-env.json pins Advanced Query Loop to an exact release so that PR CI is
+# reproducible and re-running an old green commit stays green. The trade-off is
+# that a breaking AQL release is invisible until someone bumps the pin — which
+# is exactly how AQL 5.0.0 broke the suite. This runs the suite against AQL's
+# latest release on a schedule, so we find out on our own time.
+#
+# The WordPress core axis is not covered here: the main Playwright matrix
+# already runs a non-blocking `nightly` lane against core trunk on every push.
+# So this pins core to current stable and varies only the plugin.
 #
 # It never runs on pull requests, so a failure here cannot block a merge.
 
@@ -28,7 +32,8 @@ jobs:
             pull-requests: write
         uses: ./.github/workflows/playwright-tests.yml
         with:
-            unpinned: true
+            core_matrix: '[{ "label": "7.1", "core": "WordPress/WordPress#7.1", "experimental": false }]'
+            unpinned_plugins: true
 
     report:
         name: Report drift
@@ -47,13 +52,13 @@ jobs:
               run: |
                   set -euo pipefail
 
-                  title='E2E suite fails against latest WordPress / Advanced Query Loop'
+                  title='E2E suite fails against the latest Advanced Query Loop'
                   body=$(printf '%s\n' \
-                    'The scheduled `E2E (latest upstream)` run failed.' \
+                    'The scheduled `E2E (latest AQL)` run failed.' \
                     '' \
-                    'The suite passes against the versions pinned in `.wp-env.json` but fails' \
-                    'against the latest WordPress core and Advanced Query Loop releases, so' \
-                    'bumping those pins will break PR CI until the suite is updated.' \
+                    'The suite passes against the Advanced Query Loop version pinned in' \
+                    '`.wp-env.json` but fails against its latest release, so bumping that pin' \
+                    'will break PR CI until the suite is updated.' \
                     '' \
                     "Failing run: ${RUN_URL}")
 
diff --git a/.github/workflows/playwright-tests.yml b/.github/workflows/playwright-tests.yml
index 4ca44bd..65ae93e 100644
--- a/.github/workflows/playwright-tests.yml
+++ b/.github/workflows/playwright-tests.yml
@@ -5,24 +5,70 @@ on:
         branches: [main, master, develop]
     pull_request:
         branches: [main, master, develop]
-    # Allows the scheduled `E2E (latest upstream)` workflow to reuse this job
-    # against unpinned WordPress core and Advanced Query Loop versions.
+    # Reused by the scheduled `E2E (latest AQL)` workflow, which runs a single
+    # lane against an un-pinned Advanced Query Loop.
     workflow_call:
         inputs:
-            unpinned:
+            core_matrix:
                 description: >-
-                    Ignore the versions pinned in .wp-env.json and run against
-                    the latest WordPress core and Advanced Query Loop releases.
+                    JSON array of matrix lanes, each { label, core, experimental }.
+                    Defaults to the full supported-versions matrix.
+                type: string
+                default: ''
+            unpinned_plugins:
+                description: >-
+                    Ignore the Advanced Query Loop version pinned in
+                    .wp-env.json and use its latest release instead.
                 type: boolean
                 default: false
 
 jobs:
-    test:
+    # The matrix lives here rather than inline so that a caller can narrow it
+    # to a single lane without duplicating the job below.
+    lanes:
+        name: Resolve matrix
+        runs-on: ubuntu-latest
+        outputs:
+            matrix: ${{ steps.resolve.outputs.matrix }}
+        steps:
+            - name: Resolve lanes
+              id: resolve
+              env:
+                  OVERRIDE: ${{ inputs.core_matrix }}
+              run: |
+                  set -euo pipefail
+
+                  # Core is pinned per lane to an exact tag, not a branch, so a
+                  # re-run of an old commit resolves to the same WordPress.
+                  # `nightly` is the deliberate exception: it tracks trunk to
+                  # give early warning of upstream breakage, and is marked
+                  # experimental so it cannot block a merge.
+                  read -r -d '' DEFAULT <<'JSON' || true
+                  [
+                    { "label": "6.9",     "core": "WordPress/WordPress#6.9.7",  "experimental": false },
+                    { "label": "7.0",     "core": "WordPress/WordPress#7.0.4",  "experimental": false },
+                    { "label": "7.1",     "core": "WordPress/WordPress#7.1",    "experimental": false },
+                    { "label": "nightly", "core": "WordPress/WordPress#master", "experimental": true  }
+                  ]
+                  JSON
+
+                  lanes="${OVERRIDE:-$DEFAULT}"
+                  echo "$lanes" | jq -e 'type == "array" and length > 0' > /dev/null
+                  echo "matrix=$( echo "$lanes" | jq -c . )" >> "$GITHUB_OUTPUT"
+                  echo "$lanes" | jq -r '.[] | "lane: \(.label) -> \(.core) (experimental: \(.experimental))"'
+
+    e2e:
+        name: WP ${{ matrix.label }}
+        needs: lanes
         timeout-minutes: 60
         runs-on: ubuntu-latest
         permissions:
             contents: read
             pull-requests: write
+        strategy:
+            fail-fast: false
+            matrix:
+                include: ${{ fromJSON( needs.lanes.outputs.matrix ) }}
 
         steps:
             - name: Checkout
@@ -43,15 +89,15 @@ jobs:
             - name: Install Playwright Browsers
               run: npx playwright install --with-deps chromium
 
-            # .wp-env.json pins core and Advanced Query Loop to exact versions so
-            # that re-running an old green commit stays green. This override
-            # deliberately un-pins them for the scheduled early-warning run.
-            - name: Un-pin upstream versions
-              if: inputs.unpinned
+            # .wp-env.json pins Advanced Query Loop so that re-running an old
+            # green commit stays green. This override deliberately un-pins it
+            # for the scheduled early-warning run. Core is not touched here —
+            # it comes from WP_ENV_CORE below.
+            - name: Un-pin Advanced Query Loop
+              if: inputs.unpinned_plugins
               run: |
                   cat > .wp-env.override.json <<'JSON'
                   {
-                  	"core": null,
                   	"plugins": [
                   		".",
                   		"https://downloads.wordpress.org/plugin/advanced-query-loop.zip"
@@ -62,6 +108,8 @@ jobs:
 
             - name: Start WordPress environment
               run: npm run wp-env start
+              env:
+                  WP_ENV_CORE: ${{ matrix.core }}
 
             - name: Wait for WordPress to be ready
               run: |
@@ -72,6 +120,9 @@ jobs:
               run: |
                   curl -I http://localhost:8889 || echo "WordPress not responding"
                   docker ps
+                  # Confirms the lane really is running the core it claims to,
+                  # rather than every lane silently testing the same version.
+                  npx wp-env run tests-cli wp core version || true
 
             - name: Run Playwright tests
               id: tests
@@ -88,26 +139,62 @@ jobs:
               uses: actions/upload-artifact@v4
               if: always()
               with:
-                  name: playwright-report
+                  name: playwright-report-wp-${{ matrix.label }}
                   path: test-results/
                   retention-days: 30
                   if-no-files-found: ignore
 
             - name: Upload test videos and traces
               uses: actions/upload-artifact@v4
-              if: failure()
+              if: steps.tests.outcome == 'failure'
               with:
-                  name: test-results
+                  name: test-results-wp-${{ matrix.label }}
                   path: test-results/
                   retention-days: 7
                   if-no-files-found: ignore
 
+            # Experimental lanes get a job summary only, to keep the PR thread
+            # to one sticky comment per blocking lane.
             - name: Comment PR with test results
               uses: daun/playwright-report-comment@v3
               if: always() && github.event_name == 'pull_request'
               with:
                   report-file: test-results/results.json
+                  report-tag: wp-${{ matrix.label }}
+                  comment-title: 'Playwright test results — WP ${{ matrix.label }}'
+                  create-comment: ${{ !matrix.experimental }}
+                  job-summary: true
 
             - name: Fail if tests failed
-              if: steps.tests.outcome == 'failure'
+              if: steps.tests.outcome == 'failure' && !matrix.experimental
               run: exit 1
+
+            # An experimental lane never fails the job, so that trunk breakage
+            # cannot block a merge. Surface it as an annotation instead.
+            - name: Flag experimental failure
+              if: steps.tests.outcome == 'failure' && matrix.experimental
+              run: |
+                  echo "::warning title=WP ${{ matrix.label }} e2e failed::Non-blocking lane. Upstream may have introduced a breaking change — see the job summary."
+                  {
+                    echo "### :warning: WP ${{ matrix.label }} e2e failed (non-blocking)"
+                    echo
+                    echo "This lane tracks \`${{ matrix.core }}\` and does not gate merging."
+                    echo "A failure here usually means an upstream change will break us on the next release."
+                  } >> "$GITHUB_STEP_SUMMARY"
+
+    # Aggregate gate. Named `test` so that the pre-existing required status
+    # check keeps resolving: the per-version lanes publish names ("WP 7.1")
+    # that branch protection does not know about.
+    test:
+        name: test
+        needs: e2e
+        if: always()
+        runs-on: ubuntu-latest
+        steps:
+            - name: Check lane results
+              env:
+                  RESULT: ${{ needs.e2e.result }}
+              run: |
+                  set -euo pipefail
+                  echo "Blocking lanes: $RESULT"
+                  [ "$RESULT" = "success" ]
diff --git a/.wp-env.json b/.wp-env.json
index 68e6cbb..36a21d4 100644
--- a/.wp-env.json
+++ b/.wp-env.json
@@ -1,5 +1,5 @@
 {
-	"core": "WordPress/WordPress#6.9.7",
+	"core": "WordPress/WordPress#7.1",
 	"plugins": [
 		".",
 		"https://downloads.wordpress.org/plugin/advanced-query-loop.5.0.0.zip"
diff --git a/CLAUDE.md b/CLAUDE.md
index f23850d..95e65a4 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -120,9 +120,28 @@ The plugin provides a PHP API for registering custom query presets that can be s
 
 Tests use `@wordpress/env`, configured in `.wp-env.json`. The environment includes TwentyTwentyFour and TwentyTwentyFive themes, and the Advanced Query Loop plugin. Tests run on port 8889 and use Playwright with `@wordpress/e2e-test-utils-playwright`.
 
-**Upstream versions are pinned deliberately.** `core` is pinned to an exact tag (`WordPress/WordPress#6.9.7`, not the `#6.9` branch) and Advanced Query Loop to an exact release zip. Floating refs let an upstream release break CI with no change in this repo, and make re-running an old green commit depend on the day it runs. When bumping a pin, expect to update any test that drives third-party UI.
+**Upstream versions are pinned deliberately.** Pins are exact tags/releases, never branches: floating refs let an upstream release break CI with no change in this repo, and make re-running an old green commit depend on the day it runs. When bumping a pin, expect to update any test that drives third-party UI.
 
-The scheduled `E2E (latest upstream)` workflow (`.github/workflows/e2e-latest.yml`) reuses the same Playwright job with those pins overridden to latest, so upstream drift shows up on a schedule instead of mid-PR. It never runs on pull requests, so it cannot block a merge; on failure it opens or comments on a single rolling issue.
+`.wp-env.json` holds the local development default (current stable core, plus the pinned Advanced Query Loop release). CI overrides only the core axis per matrix lane via the `WP_ENV_CORE` environment variable, which takes precedence over `.wp-env.json` for both the dev and tests environments.
+
+### CI matrix
+
+`.github/workflows/playwright-tests.yml` runs the suite across WordPress versions. The lanes are defined as JSON in the `lanes` job, so a caller can narrow them without duplicating the test job:
+
+| Lane | Core | Blocking |
+| --- | --- | --- |
+| `6.9` | `WordPress/WordPress#6.9.7` | yes |
+| `7.0` | `WordPress/WordPress#7.0.4` | yes |
+| `7.1` | `WordPress/WordPress#7.1` | yes |
+| `nightly` | `WordPress/WordPress#master` | no (`experimental: true`) |
+
+The `nightly` lane deliberately tracks trunk for early warning. It never fails its job, so trunk breakage cannot block a merge; a failure surfaces as a `::warning::` annotation and a job summary instead.
+
+An aggregate job named `test` gates on the blocking lanes only. **Keep that job id** — it is the name branch protection resolves; the per-version lanes publish names (`WP 7.1`) that branch protection does not know about.
+
+### Scheduled canary
+
+The scheduled `E2E (latest AQL)` workflow (`.github/workflows/e2e-latest.yml`) reuses the same Playwright job with a single pinned-core lane and Advanced Query Loop un-pinned, so a breaking AQL release shows up on a schedule instead of mid-PR (which is exactly how AQL 5.0.0 broke the suite). Core trunk is not covered there because the `nightly` matrix lane already does it on every push. It never runs on pull requests, so it cannot block a merge; on failure it opens or comments on a single rolling issue.
 
 ## Important Implementation Notes
 

From d0fd2525b22f3fe533d539355a3b99b8814f13a7 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 9 Sep 2026 12:32:33 +0000
Subject: [PATCH 3/7] Tests: upgrade the database fixture to the running
 WordPress version

The new 7.0, 7.1 and nightly matrix lanes all failed before running a single
test, timing out in global-setup.js waiting for login to reach wp-admin.

tests/e2e/database.sql is a dump taken on WordPress 6.9, so it pins
`db_version` to 60717. WordPress 7.0.4, 7.1 and trunk all expect 61833, so
core treated the imported database as out of date and redirected every admin
request to wp-admin/upgrade.php. That matches neither `**/wp-admin/` nor
`#wpadminbar`, so login timed out and the suite reported 0 tests. The 6.9 lane
was unaffected because its db_version matches the dump.

Run `wp core update-db` after importing, which keeps the fixture
version-agnostic and is a no-op when the versions already match.

Also report the landing URL when login fails. The timeout alone gave no
indication that the browser was sitting on upgrade.php.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Uc1T67ac4VvePFBhENPbki
---
 tests/e2e/fixtures.js     | 7 +++++++
 tests/e2e/global-setup.js | 9 ++++++++-
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/tests/e2e/fixtures.js b/tests/e2e/fixtures.js
index 88fd6cf..07f1d6e 100644
--- a/tests/e2e/fixtures.js
+++ b/tests/e2e/fixtures.js
@@ -272,5 +272,12 @@ export function resetDatabase() {
 	wpCli(
 		`wp db import /var/www/html/wp-content/plugins/hm-query-loop/tests/e2e/database.sql`
 	);
+	// database.sql is a dump taken on one WordPress version, so it pins
+	// `db_version` to whatever that was. On any other version core treats the
+	// database as out of date and redirects every admin request to
+	// wp-admin/upgrade.php, which makes the login in global-setup.js time out
+	// before a single test runs. Upgrading keeps the fixture version-agnostic,
+	// and is a no-op when the versions already match.
+	wpCli( `wp core update-db` );
 	wpCli( `wp cache flush` );
 }
diff --git a/tests/e2e/global-setup.js b/tests/e2e/global-setup.js
index bdc387a..9facd7e 100644
--- a/tests/e2e/global-setup.js
+++ b/tests/e2e/global-setup.js
@@ -32,7 +32,14 @@ module.exports = async () => {
 			page.waitForSelector( '#wpadminbar', { timeout: 15000 } ),
 		] );
 	} catch ( error ) {
-		console.error( 'Failed to log in to WordPress' );
+		// Report where login actually landed. WordPress bounces admin requests
+		// to interstitials (wp-admin/upgrade.php when the database is behind
+		// core, the admin email confirmation screen, and so on), none of which
+		// match the conditions above — and without the URL the timeout alone
+		// gives no clue which one it was.
+		console.error(
+			`Failed to log in to WordPress. Landed on: ${ page.url() }`
+		);
 		await browser.close();
 		throw error;
 	}

From c3bb2d4e9df4ef54ddacef0e240a8ef4cbe564e0 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 9 Sep 2026 12:45:54 +0000
Subject: [PATCH 4/7] Tests: make the settings sidebar helper work in the WP
 7.x site editor

With login fixed, the 7.0 lane ran all 22 tests and 8 failed. The failures
correlate exactly with one call: every spec that opens the settings sidebar in
the site editor failed, and every spec that does not passed.

editor.openDocumentSettingsSidebar() from @wordpress/e2e-test-utils-playwright
requires a button named exactly "Settings" inside the "Editor top bar" region.
That button is not reachable in the site editor on WordPress 7.x, so the
locator never resolved and the helper timed out before any assertion ran. The
same specs pass in the post editor on the same WordPress.

Ruled out along the way:

- Not a stale test-utils package. openDocumentSettingsSidebar is byte-identical
  in 1.33.2 (wp-6.9), 1.40.1 (wp-7.0), 1.50.0 (pinned here) and 1.54.0, so
  bumping it changes nothing.
- Not a renamed landmark. The "Editor top bar" and "Editor settings" region
  labels are unchanged between the 6.9.7 and 7.1 builds of editor.js.
- Not a renamed panel class. components-panel__body-title still exists in the
  7.1 build of components.js.
- Not a broken site editor. The test asserting the site editor layout loads
  passed on 7.0.

Return early when the sidebar is already open, and fall back to any Settings
toggle when the core helper cannot find its own. No assertion is weakened and
no test is skipped.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Uc1T67ac4VvePFBhENPbki
---
 tests/e2e/fixtures.js | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/tests/e2e/fixtures.js b/tests/e2e/fixtures.js
index 07f1d6e..c53e2ea 100644
--- a/tests/e2e/fixtures.js
+++ b/tests/e2e/fixtures.js
@@ -88,9 +88,39 @@ export const test = base.extend( {
 
 			/**
 			 * Open the settings sidebar and wait for it to be ready.
+			 *
+			 * editor.openDocumentSettingsSidebar() insists on a header button
+			 * named exactly "Settings" inside the "Editor top bar" region. That
+			 * button is not reachable in the site editor on WordPress 7.x, so
+			 * every test that opened the sidebar there timed out while the same
+			 * tests passed in the post editor. Check whether the sidebar is
+			 * already open first, and fall back to any Settings toggle if the
+			 * core helper cannot find its own.
 			 */
 			async openSettingsSidebar() {
-				await editor.openDocumentSettingsSidebar();
+				const settingsRegion = page.getByRole( 'region', {
+					name: 'Editor settings',
+				} );
+
+				if (
+					await settingsRegion
+						.isVisible( { timeout: 2000 } )
+						.catch( () => false )
+				) {
+					await page.waitForTimeout( 1000 );
+					return;
+				}
+
+				try {
+					await editor.openDocumentSettingsSidebar();
+				} catch ( error ) {
+					await page
+						.getByRole( 'button', { name: 'Settings' } )
+						.first()
+						.click();
+					await settingsRegion.waitFor( { timeout: 15000 } );
+				}
+
 				await page.waitForTimeout( 1000 );
 			},
 

From e29ff095aebacae828137e470e8a93a9872870b4 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 9 Sep 2026 12:55:04 +0000
Subject: [PATCH 5/7] Tests: select the Block tab after opening the settings
 sidebar
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous commit got the sidebar open on WordPress 7.x — the
openDocumentSettingsSidebar timeout is gone from the 7.0 log. The same 8 tests
still fail, but now on a different locator: the plugin's own controls
("Query Preset", and the "Extra Query Loop Settings" panel behind the posts
per page and ElasticPress tests) are not found.

Those panels are block inspector controls on core/query. They render correctly
in the post editor on WordPress 7.0 — multiple-post-templates exercises the
plugin's own inspector controls there and passes — so the panels themselves are
fine and the site editor sidebar is simply not showing the Block tab.

Select the Block tab when the editor offers one. It is a no-op where that tab
is already active, so the 6.9 lane is unaffected.

This does not cover everything on 7.1, which additionally fails
multiple-post-templates and a frontend preset assertion. Those are separate and
still unexplained.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Uc1T67ac4VvePFBhENPbki
---
 tests/e2e/fixtures.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/e2e/fixtures.js b/tests/e2e/fixtures.js
index c53e2ea..bf1361d 100644
--- a/tests/e2e/fixtures.js
+++ b/tests/e2e/fixtures.js
@@ -121,6 +121,21 @@ export const test = base.extend( {
 					await settingsRegion.waitFor( { timeout: 15000 } );
 				}
 
+				// The sidebar can open on the Template/Document tab, which holds
+				// no block inspector controls — so every panel this plugin adds
+				// to core/query looks missing. The same panels render fine in the
+				// post editor on the same WordPress, which is what points at the
+				// tab rather than at the panels themselves.
+				const blockTab = page.getByRole( 'tab', { name: 'Block' } );
+				if (
+					await blockTab
+						.isVisible( { timeout: 2000 } )
+						.catch( () => false )
+				) {
+					await blockTab.click();
+					await page.waitForTimeout( 300 );
+				}
+
 				await page.waitForTimeout( 1000 );
 			},
 

From 8bf9faa5b8d2ffc9c266592c480a621c3b28b0db Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 9 Sep 2026 12:59:07 +0000
Subject: [PATCH 6/7] CI: isolate the experimental lane so it cannot block a
 merge
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The nightly lane failed wp-env start with ERR_SOCKET_CLOSED_BEFORE_CONNECTION —
a Docker/network blip, not a test failure — and that failed the whole run.

The non-blocking mechanism only exempted the Playwright step, so any earlier
step failing still failed the lane's job. Because the aggregate gate keyed off
the matrix result, and the matrix contained trunk, an infrastructure hiccup on
trunk blocked the PR. That is the opposite of what marking it experimental was
meant to achieve.

Move the experimental lanes into their own job and leave it out of the
aggregate's `needs` entirely, so "non-blocking" no longer depends on which step
happened to fail.

To keep the blocking and experimental paths from drifting, the shared steps
move into a composite action. `continue-on-error` is not available to composite
steps, so the suite records its own `outcome` output and each caller decides
whether that is fatal.

Also stop `wp-env stop` failing the job when the environment never came up.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Uc1T67ac4VvePFBhENPbki
---
 .github/actions/e2e-suite/action.yml   | 127 ++++++++++++++++
 .github/workflows/e2e-latest.yml       |   4 +-
 .github/workflows/playwright-tests.yml | 195 ++++++++++---------------
 CLAUDE.md                              |  22 +--
 4 files changed, 223 insertions(+), 125 deletions(-)
 create mode 100644 .github/actions/e2e-suite/action.yml

diff --git a/.github/actions/e2e-suite/action.yml b/.github/actions/e2e-suite/action.yml
new file mode 100644
index 0000000..237f119
--- /dev/null
+++ b/.github/actions/e2e-suite/action.yml
@@ -0,0 +1,127 @@
+name: Run e2e suite
+description: >-
+    Build the plugin, boot wp-env against a given WordPress core, and run the
+    Playwright suite. Shared by the blocking and experimental matrix jobs so
+    the two cannot drift apart.
+
+inputs:
+    label:
+        description: Short lane name, used in artifact names (e.g. "7.1").
+        required: true
+    core:
+        description: wp-env core source for this lane (e.g. WordPress/WordPress#7.1).
+        required: true
+    unpinned_plugins:
+        description: >-
+            When "true", ignore the Advanced Query Loop version pinned in
+            .wp-env.json and use its latest release.
+        required: false
+        default: 'false'
+    comment_on_pr:
+        description: Whether to leave a sticky Playwright report comment on the PR.
+        required: false
+        default: 'false'
+
+outputs:
+    outcome:
+        description: '"success" or "failure" — whether the Playwright run passed.'
+        value: ${{ steps.tests.outputs.outcome }}
+
+runs:
+    using: composite
+    steps:
+        - name: Setup Node.js
+          uses: actions/setup-node@v4
+          with:
+              node-version: 24
+              cache: 'npm'
+
+        - name: Install dependencies
+          shell: bash
+          run: npm i
+
+        - name: Build plugin
+          shell: bash
+          run: npm run build
+
+        - name: Install Playwright Browsers
+          shell: bash
+          run: npx playwright install --with-deps chromium
+
+        # .wp-env.json pins Advanced Query Loop so that re-running an old green
+        # commit stays green. This override deliberately un-pins it for the
+        # scheduled early-warning run. Core is not touched here — it comes from
+        # WP_ENV_CORE below.
+        - name: Un-pin Advanced Query Loop
+          if: inputs.unpinned_plugins == 'true'
+          shell: bash
+          run: |
+              cat > .wp-env.override.json <<'JSON'
+              {
+              	"plugins": [
+              		".",
+              		"https://downloads.wordpress.org/plugin/advanced-query-loop.zip"
+              	]
+              }
+              JSON
+              cat .wp-env.override.json
+
+        - name: Start WordPress environment
+          shell: bash
+          env:
+              WP_ENV_CORE: ${{ inputs.core }}
+          run: npm run wp-env start
+
+        - name: Wait for WordPress to be ready
+          shell: bash
+          run: |
+              timeout 60 bash -c 'until curl -sSf http://localhost:8889 > /dev/null 2>&1; do sleep 2; done' || echo "WordPress may not be fully ready"
+              sleep 5
+
+        - name: Debug - Check WordPress status
+          shell: bash
+          run: |
+              curl -I http://localhost:8889 || echo "WordPress not responding"
+              docker ps
+              # Confirms the lane really is running the core it claims to,
+              # rather than every lane silently testing the same version.
+              npx wp-env run tests-cli wp core version || true
+
+        # continue-on-error is not available to composite steps, so record the
+        # outcome by hand and let the caller decide whether it is fatal.
+        - name: Run Playwright tests
+          id: tests
+          shell: bash
+          env:
+              CI: true
+          run: |
+              if npm run test:e2e; then
+                echo "outcome=success" >> "$GITHUB_OUTPUT"
+              else
+                echo "outcome=failure" >> "$GITHUB_OUTPUT"
+              fi
+
+        - name: Stop WordPress environment
+          if: always()
+          shell: bash
+          run: npm run wp-env stop || true
+
+        - name: Upload test results
+          uses: actions/upload-artifact@v4
+          if: always()
+          with:
+              name: playwright-report-wp-${{ inputs.label }}
+              path: test-results/
+              retention-days: 30
+              if-no-files-found: ignore
+
+        - name: Comment PR with test results
+          uses: daun/playwright-report-comment@v3
+          if: always() && github.event_name == 'pull_request'
+          continue-on-error: true
+          with:
+              report-file: test-results/results.json
+              report-tag: wp-${{ inputs.label }}
+              comment-title: 'Playwright test results — WP ${{ inputs.label }}'
+              create-comment: ${{ inputs.comment_on_pr }}
+              job-summary: true
diff --git a/.github/workflows/e2e-latest.yml b/.github/workflows/e2e-latest.yml
index a8f375a..93e1aba 100644
--- a/.github/workflows/e2e-latest.yml
+++ b/.github/workflows/e2e-latest.yml
@@ -32,7 +32,9 @@ jobs:
             pull-requests: write
         uses: ./.github/workflows/playwright-tests.yml
         with:
-            core_matrix: '[{ "label": "7.1", "core": "WordPress/WordPress#7.1", "experimental": false }]'
+            core_matrix: '[{ "label": "7.1", "core": "WordPress/WordPress#7.1" }]'
+            # Core trunk is already covered by the nightly lane on every push.
+            experimental_matrix: '[]'
             unpinned_plugins: true
 
     report:
diff --git a/.github/workflows/playwright-tests.yml b/.github/workflows/playwright-tests.yml
index 65ae93e..43006b8 100644
--- a/.github/workflows/playwright-tests.yml
+++ b/.github/workflows/playwright-tests.yml
@@ -11,8 +11,14 @@ on:
         inputs:
             core_matrix:
                 description: >-
-                    JSON array of matrix lanes, each { label, core, experimental }.
-                    Defaults to the full supported-versions matrix.
+                    JSON array of blocking lanes, each { label, core }.
+                    Defaults to the supported-versions matrix.
+                type: string
+                default: ''
+            experimental_matrix:
+                description: >-
+                    JSON array of non-blocking lanes, each { label, core }.
+                    Pass '[]' to run none. Defaults to WordPress trunk.
                 type: string
                 default: ''
             unpinned_plugins:
@@ -23,39 +29,51 @@ on:
                 default: false
 
 jobs:
-    # The matrix lives here rather than inline so that a caller can narrow it
-    # to a single lane without duplicating the job below.
+    # Lanes live here rather than inline so a caller can narrow them without
+    # duplicating the jobs below.
     lanes:
         name: Resolve matrix
         runs-on: ubuntu-latest
         outputs:
-            matrix: ${{ steps.resolve.outputs.matrix }}
+            blocking: ${{ steps.resolve.outputs.blocking }}
+            experimental: ${{ steps.resolve.outputs.experimental }}
         steps:
             - name: Resolve lanes
               id: resolve
               env:
-                  OVERRIDE: ${{ inputs.core_matrix }}
+                  BLOCKING_OVERRIDE: ${{ inputs.core_matrix }}
+                  EXPERIMENTAL_OVERRIDE: ${{ inputs.experimental_matrix }}
               run: |
                   set -euo pipefail
 
                   # Core is pinned per lane to an exact tag, not a branch, so a
                   # re-run of an old commit resolves to the same WordPress.
-                  # `nightly` is the deliberate exception: it tracks trunk to
-                  # give early warning of upstream breakage, and is marked
-                  # experimental so it cannot block a merge.
-                  read -r -d '' DEFAULT <<'JSON' || true
+                  read -r -d '' DEFAULT_BLOCKING <<'JSON' || true
+                  [
+                    { "label": "6.9", "core": "WordPress/WordPress#6.9.7" },
+                    { "label": "7.0", "core": "WordPress/WordPress#7.0.4" },
+                    { "label": "7.1", "core": "WordPress/WordPress#7.1"   }
+                  ]
+                  JSON
+
+                  # Tracks trunk for early warning of upstream breakage.
+                  read -r -d '' DEFAULT_EXPERIMENTAL <<'JSON' || true
                   [
-                    { "label": "6.9",     "core": "WordPress/WordPress#6.9.7",  "experimental": false },
-                    { "label": "7.0",     "core": "WordPress/WordPress#7.0.4",  "experimental": false },
-                    { "label": "7.1",     "core": "WordPress/WordPress#7.1",    "experimental": false },
-                    { "label": "nightly", "core": "WordPress/WordPress#master", "experimental": true  }
+                    { "label": "nightly", "core": "WordPress/WordPress#master" }
                   ]
                   JSON
 
-                  lanes="${OVERRIDE:-$DEFAULT}"
-                  echo "$lanes" | jq -e 'type == "array" and length > 0' > /dev/null
-                  echo "matrix=$( echo "$lanes" | jq -c . )" >> "$GITHUB_OUTPUT"
-                  echo "$lanes" | jq -r '.[] | "lane: \(.label) -> \(.core) (experimental: \(.experimental))"'
+                  blocking="${BLOCKING_OVERRIDE:-$DEFAULT_BLOCKING}"
+                  experimental="${EXPERIMENTAL_OVERRIDE:-$DEFAULT_EXPERIMENTAL}"
+
+                  echo "$blocking" | jq -e 'type == "array" and length > 0' > /dev/null
+                  echo "$experimental" | jq -e 'type == "array"' > /dev/null
+
+                  echo "blocking=$( echo "$blocking" | jq -c . )" >> "$GITHUB_OUTPUT"
+                  echo "experimental=$( echo "$experimental" | jq -c . )" >> "$GITHUB_OUTPUT"
+
+                  echo "$blocking" | jq -r '.[] | "blocking: \(.label) -> \(.core)"'
+                  echo "$experimental" | jq -r '.[] | "experimental: \(.label) -> \(.core)"'
 
     e2e:
         name: WP ${{ matrix.label }}
@@ -68,111 +86,58 @@ jobs:
         strategy:
             fail-fast: false
             matrix:
-                include: ${{ fromJSON( needs.lanes.outputs.matrix ) }}
-
+                include: ${{ fromJSON( needs.lanes.outputs.blocking ) }}
         steps:
             - name: Checkout
               uses: actions/checkout@v4
 
-            - name: Setup Node.js
-              uses: actions/setup-node@v4
+            - name: Run e2e suite
+              id: suite
+              uses: ./.github/actions/e2e-suite
               with:
-                  node-version: 24
-                  cache: 'npm'
-
-            - name: Install dependencies
-              run: npm i
-
-            - name: Build plugin
-              run: npm run build
-
-            - name: Install Playwright Browsers
-              run: npx playwright install --with-deps chromium
-
-            # .wp-env.json pins Advanced Query Loop so that re-running an old
-            # green commit stays green. This override deliberately un-pins it
-            # for the scheduled early-warning run. Core is not touched here —
-            # it comes from WP_ENV_CORE below.
-            - name: Un-pin Advanced Query Loop
-              if: inputs.unpinned_plugins
-              run: |
-                  cat > .wp-env.override.json <<'JSON'
-                  {
-                  	"plugins": [
-                  		".",
-                  		"https://downloads.wordpress.org/plugin/advanced-query-loop.zip"
-                  	]
-                  }
-                  JSON
-                  cat .wp-env.override.json
-
-            - name: Start WordPress environment
-              run: npm run wp-env start
-              env:
-                  WP_ENV_CORE: ${{ matrix.core }}
-
-            - name: Wait for WordPress to be ready
-              run: |
-                  timeout 60 bash -c 'until curl -sSf http://localhost:8889 > /dev/null 2>&1; do sleep 2; done' || echo "WordPress may not be fully ready"
-                  sleep 5
-
-            - name: Debug - Check WordPress status
-              run: |
-                  curl -I http://localhost:8889 || echo "WordPress not responding"
-                  docker ps
-                  # Confirms the lane really is running the core it claims to,
-                  # rather than every lane silently testing the same version.
-                  npx wp-env run tests-cli wp core version || true
+                  label: ${{ matrix.label }}
+                  core: ${{ matrix.core }}
+                  unpinned_plugins: ${{ inputs.unpinned_plugins }}
+                  comment_on_pr: 'true'
 
-            - name: Run Playwright tests
-              id: tests
-              continue-on-error: true
-              run: npm run test:e2e
-              env:
-                  CI: true
-
-            - name: Stop WordPress environment
-              if: always()
-              run: npm run wp-env stop
-
-            - name: Upload test results
-              uses: actions/upload-artifact@v4
-              if: always()
-              with:
-                  name: playwright-report-wp-${{ matrix.label }}
-                  path: test-results/
-                  retention-days: 30
-                  if-no-files-found: ignore
+            - name: Fail if tests failed
+              if: steps.suite.outputs.outcome == 'failure'
+              run: exit 1
 
-            - name: Upload test videos and traces
-              uses: actions/upload-artifact@v4
-              if: steps.tests.outcome == 'failure'
-              with:
-                  name: test-results-wp-${{ matrix.label }}
-                  path: test-results/
-                  retention-days: 7
-                  if-no-files-found: ignore
+    # Separate job, and deliberately NOT in the aggregate's `needs`. Keeping
+    # trunk in the same matrix meant any failure here — including an infra
+    # blip in wp-env start, which is what happened — dragged the whole matrix
+    # result down and blocked the PR. Isolating it makes "non-blocking"
+    # unconditional rather than dependent on which step failed.
+    e2e-experimental:
+        name: WP ${{ matrix.label }}
+        needs: lanes
+        if: needs.lanes.outputs.experimental != '[]'
+        timeout-minutes: 60
+        runs-on: ubuntu-latest
+        continue-on-error: true
+        permissions:
+            contents: read
+            pull-requests: write
+        strategy:
+            fail-fast: false
+            matrix:
+                include: ${{ fromJSON( needs.lanes.outputs.experimental ) }}
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
 
-            # Experimental lanes get a job summary only, to keep the PR thread
-            # to one sticky comment per blocking lane.
-            - name: Comment PR with test results
-              uses: daun/playwright-report-comment@v3
-              if: always() && github.event_name == 'pull_request'
+            - name: Run e2e suite
+              id: suite
+              uses: ./.github/actions/e2e-suite
               with:
-                  report-file: test-results/results.json
-                  report-tag: wp-${{ matrix.label }}
-                  comment-title: 'Playwright test results — WP ${{ matrix.label }}'
-                  create-comment: ${{ !matrix.experimental }}
-                  job-summary: true
-
-            - name: Fail if tests failed
-              if: steps.tests.outcome == 'failure' && !matrix.experimental
-              run: exit 1
+                  label: ${{ matrix.label }}
+                  core: ${{ matrix.core }}
+                  unpinned_plugins: ${{ inputs.unpinned_plugins }}
+                  comment_on_pr: 'false'
 
-            # An experimental lane never fails the job, so that trunk breakage
-            # cannot block a merge. Surface it as an annotation instead.
             - name: Flag experimental failure
-              if: steps.tests.outcome == 'failure' && matrix.experimental
+              if: steps.suite.outputs.outcome == 'failure'
               run: |
                   echo "::warning title=WP ${{ matrix.label }} e2e failed::Non-blocking lane. Upstream may have introduced a breaking change — see the job summary."
                   {
@@ -182,9 +147,9 @@ jobs:
                     echo "A failure here usually means an upstream change will break us on the next release."
                   } >> "$GITHUB_STEP_SUMMARY"
 
-    # Aggregate gate. Named `test` so that the pre-existing required status
-    # check keeps resolving: the per-version lanes publish names ("WP 7.1")
-    # that branch protection does not know about.
+    # Aggregate gate. Named `test` so the pre-existing required status check
+    # keeps resolving: the per-version lanes publish names ("WP 7.1") that
+    # branch protection does not know about.
     test:
         name: test
         needs: e2e
diff --git a/CLAUDE.md b/CLAUDE.md
index 95e65a4..131d991 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -126,18 +126,22 @@ Tests use `@wordpress/env`, configured in `.wp-env.json`. The environment includ
 
 ### CI matrix
 
-`.github/workflows/playwright-tests.yml` runs the suite across WordPress versions. The lanes are defined as JSON in the `lanes` job, so a caller can narrow them without duplicating the test job:
+`.github/workflows/playwright-tests.yml` runs the suite across WordPress versions. Lanes are defined as JSON in the `lanes` job, so a caller can narrow them without duplicating anything:
 
-| Lane | Core | Blocking |
-| --- | --- | --- |
-| `6.9` | `WordPress/WordPress#6.9.7` | yes |
-| `7.0` | `WordPress/WordPress#7.0.4` | yes |
-| `7.1` | `WordPress/WordPress#7.1` | yes |
-| `nightly` | `WordPress/WordPress#master` | no (`experimental: true`) |
+| Lane | Core | Job | Blocking |
+| --- | --- | --- | --- |
+| `6.9` | `WordPress/WordPress#6.9.7` | `e2e` | yes |
+| `7.0` | `WordPress/WordPress#7.0.4` | `e2e` | yes |
+| `7.1` | `WordPress/WordPress#7.1` | `e2e` | yes |
+| `nightly` | `WordPress/WordPress#master` | `e2e-experimental` | no |
 
-The `nightly` lane deliberately tracks trunk for early warning. It never fails its job, so trunk breakage cannot block a merge; a failure surfaces as a `::warning::` annotation and a job summary instead.
+The `nightly` lane deliberately tracks trunk for early warning; a failure surfaces as a `::warning::` annotation and a job summary.
 
-An aggregate job named `test` gates on the blocking lanes only. **Keep that job id** — it is the name branch protection resolves; the per-version lanes publish names (`WP 7.1`) that branch protection does not know about.
+Three structural points, each of which fixes a bug that actually happened:
+
+- **Experimental lanes are a separate job, deliberately excluded from the aggregate's `needs`.** When trunk shared the blocking matrix, *any* failure in it — including an infrastructure blip in `wp-env start` — dragged the matrix result down and blocked the PR. Exempting only the test step is not enough; the lane has to be out of the gate entirely.
+- **The aggregate job id is `test`.** That is the name branch protection resolves; the per-version lanes publish names (`WP 7.1`) it does not know about. Renaming or removing that job silently strands any required status check.
+- **Steps live in a composite action** (`.github/actions/e2e-suite`) shared by both jobs, so the blocking and experimental paths cannot drift. `continue-on-error` is unavailable to composite steps, so the suite records its own `outcome` output and each caller decides whether that is fatal. Artifact names and report tags are per lane, because `upload-artifact@v4` rejects duplicate names.
 
 ### Scheduled canary
 

From 5f75c3eaa981267c74529b81b530cc2f62169b07 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 9 Sep 2026 13:19:25 +0000
Subject: [PATCH 7/7] CI: make the 7.0 and 7.1 lanes non-blocking pending WP
 7.x fixes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The matrix works and WordPress 6.9 is green, but 7.0 (8 failures) and 7.1 (11)
fail on genuine compatibility gaps that predate this work: the plugin's
core/query inspector panels are not found in the 7.x site editor, and 7.1 also
fails multiple-post-templates and a frontend preset assertion.

Gating merges on that would block every PR on pre-existing breakage, so move
both lanes into the experimental job. They still run and report on every PR —
no test is skipped or weakened — and move back to DEFAULT_BLOCKING once the
gaps are closed.

Lanes now carry a `comment` flag rather than the job deciding, so 7.0 and 7.1
keep reporting into the PR thread while nightly stays out of it.

Also repoint the scheduled AQL canary from 7.1 to 6.9. Running it against a
known-red lane would have failed every week on the WordPress 7.x gaps and
buried the signal it exists to give.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Uc1T67ac4VvePFBhENPbki
---
 .github/workflows/e2e-latest.yml       |  5 ++++-
 .github/workflows/playwright-tests.yml | 25 +++++++++++++++----------
 CLAUDE.md                              |  8 +++++---
 3 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/e2e-latest.yml b/.github/workflows/e2e-latest.yml
index 93e1aba..d726117 100644
--- a/.github/workflows/e2e-latest.yml
+++ b/.github/workflows/e2e-latest.yml
@@ -32,7 +32,10 @@ jobs:
             pull-requests: write
         uses: ./.github/workflows/playwright-tests.yml
         with:
-            core_matrix: '[{ "label": "7.1", "core": "WordPress/WordPress#7.1" }]'
+            # Pinned to the lane that is green, so a failure here means an AQL
+            # regression and nothing else. Pointing this at 7.0/7.1 would fail
+            # every week on the known WordPress 7.x gaps and bury the signal.
+            core_matrix: '[{ "label": "6.9", "core": "WordPress/WordPress#6.9.7", "comment": false }]'
             # Core trunk is already covered by the nightly lane on every push.
             experimental_matrix: '[]'
             unpinned_plugins: true
diff --git a/.github/workflows/playwright-tests.yml b/.github/workflows/playwright-tests.yml
index 43006b8..124f982 100644
--- a/.github/workflows/playwright-tests.yml
+++ b/.github/workflows/playwright-tests.yml
@@ -50,16 +50,20 @@ jobs:
                   # re-run of an old commit resolves to the same WordPress.
                   read -r -d '' DEFAULT_BLOCKING <<'JSON' || true
                   [
-                    { "label": "6.9", "core": "WordPress/WordPress#6.9.7" },
-                    { "label": "7.0", "core": "WordPress/WordPress#7.0.4" },
-                    { "label": "7.1", "core": "WordPress/WordPress#7.1"   }
+                    { "label": "6.9", "core": "WordPress/WordPress#6.9.7", "comment": true }
                   ]
                   JSON
 
-                  # Tracks trunk for early warning of upstream breakage.
+                  # 7.0 and 7.1 run on every PR but do not gate merging: the
+                  # suite has real compatibility gaps on WordPress 7.x that
+                  # predate this matrix (see the WP 7.x tracking issue). They
+                  # move back to DEFAULT_BLOCKING once those are closed.
+                  # nightly tracks trunk for early warning and stays here.
                   read -r -d '' DEFAULT_EXPERIMENTAL <<'JSON' || true
                   [
-                    { "label": "nightly", "core": "WordPress/WordPress#master" }
+                    { "label": "7.0",     "core": "WordPress/WordPress#7.0.4",  "comment": true  },
+                    { "label": "7.1",     "core": "WordPress/WordPress#7.1",    "comment": true  },
+                    { "label": "nightly", "core": "WordPress/WordPress#master", "comment": false }
                   ]
                   JSON
 
@@ -98,7 +102,7 @@ jobs:
                   label: ${{ matrix.label }}
                   core: ${{ matrix.core }}
                   unpinned_plugins: ${{ inputs.unpinned_plugins }}
-                  comment_on_pr: 'true'
+                  comment_on_pr: ${{ matrix.comment }}
 
             - name: Fail if tests failed
               if: steps.suite.outputs.outcome == 'failure'
@@ -134,17 +138,18 @@ jobs:
                   label: ${{ matrix.label }}
                   core: ${{ matrix.core }}
                   unpinned_plugins: ${{ inputs.unpinned_plugins }}
-                  comment_on_pr: 'false'
+                  comment_on_pr: ${{ matrix.comment }}
 
             - name: Flag experimental failure
               if: steps.suite.outputs.outcome == 'failure'
               run: |
-                  echo "::warning title=WP ${{ matrix.label }} e2e failed::Non-blocking lane. Upstream may have introduced a breaking change — see the job summary."
+                  echo "::warning title=WP ${{ matrix.label }} e2e failed::Non-blocking lane — see the job summary."
                   {
                     echo "### :warning: WP ${{ matrix.label }} e2e failed (non-blocking)"
                     echo
-                    echo "This lane tracks \`${{ matrix.core }}\` and does not gate merging."
-                    echo "A failure here usually means an upstream change will break us on the next release."
+                    echo "This lane runs \`${{ matrix.core }}\` and does not gate merging."
+                    echo "For trunk, a failure is early warning of an upstream change."
+                    echo "For a released version, it is a known compatibility gap — see the WP 7.x tracking issue."
                   } >> "$GITHUB_STEP_SUMMARY"
 
     # Aggregate gate. Named `test` so the pre-existing required status check
diff --git a/CLAUDE.md b/CLAUDE.md
index 131d991..58d5918 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -131,11 +131,13 @@ Tests use `@wordpress/env`, configured in `.wp-env.json`. The environment includ
 | Lane | Core | Job | Blocking |
 | --- | --- | --- | --- |
 | `6.9` | `WordPress/WordPress#6.9.7` | `e2e` | yes |
-| `7.0` | `WordPress/WordPress#7.0.4` | `e2e` | yes |
-| `7.1` | `WordPress/WordPress#7.1` | `e2e` | yes |
+| `7.0` | `WordPress/WordPress#7.0.4` | `e2e-experimental` | no |
+| `7.1` | `WordPress/WordPress#7.1` | `e2e-experimental` | no |
 | `nightly` | `WordPress/WordPress#master` | `e2e-experimental` | no |
 
-The `nightly` lane deliberately tracks trunk for early warning; a failure surfaces as a `::warning::` annotation and a job summary.
+A failure in a non-blocking lane surfaces as a `::warning::` annotation and a job summary. For `nightly` that is early warning of an upstream change; for `7.0`/`7.1` it is a known compatibility gap.
+
+**7.0 and 7.1 are non-blocking only until the WordPress 7.x gaps are closed.** They run on every PR and report, but the suite genuinely fails on 7.x — the plugin's `core/query` inspector panels are not found in the 7.x site editor, and 7.1 additionally fails `multiple-post-templates` and a *frontend* preset assertion that cannot be a selector problem. Move them back into `DEFAULT_BLOCKING` in the `lanes` job once that is fixed. Lanes carry a `comment` flag so `nightly` stays out of the PR thread while the released versions report into it.
 
 Three structural points, each of which fixes a bug that actually happened: