diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8e35b6b07f..a1fb49d057 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -11,8 +11,39 @@ concurrency:
   group: validation-${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 jobs:
+  changes:
+    name: Detect changes
+    runs-on: ubuntu-24.04
+    outputs:
+      code: ${{ steps.filter.outputs.code }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ github.sha }}
+          fetch-depth: 0
+      - id: filter
+        run: |
+          if [ "${{ github.event_name }}" = "push" ] && [ "${{ github.ref }}" = "refs/heads/main" ]; then
+            echo "code=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          BASE="${{ github.event.pull_request.base.sha }}"
+          if [ -z "$BASE" ]; then BASE="HEAD~1"; fi
+          CHANGED=$(git diff --name-only "$BASE" HEAD || echo "")
+          if [ -z "$CHANGED" ]; then
+            echo "code=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          if echo "$CHANGED" | grep -qvE '^(docs/|\.md$|\.txt$|LICENSE|\.github/ISSUE_TEMPLATE/)'; then
+            echo "code=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "code=false" >> "$GITHUB_OUTPUT"
+            echo "Only documentation changes detected, skipping heavy tests"
+          fi
   windows-install:
     name: Native Windows install
+    needs: changes
+    if: needs.changes.outputs.code == 'true'
     runs-on: windows-latest
     timeout-minutes: 10
     env:
@@ -31,6 +62,8 @@ jobs:
       - run: bun test ./scripts/windows-plugin.test.ts ./scripts/plugin-runtime.test.ts ./scripts/phone-setup.test.ts ./server/windows-native.test.ts
   macos-session:
     name: Native macOS session identity
+    needs: changes
+    if: needs.changes.outputs.code == 'true'
     runs-on: macos-15
     timeout-minutes: 5
     env:
@@ -61,8 +94,6 @@ jobs:
         with:
           node-version: '22'
       - run: bun install --frozen-lockfile
-      # scripts/check.ts is what a developer runs too: workflow syntax (checksum-pinned actionlint),
-      # generated types, typecheck, build, unit tests (no herdr required)
       - run: bun run check fast
       - name: Preserve check report and verification logs
         if: always()
@@ -78,11 +109,12 @@ jobs:
           include-hidden-files: true
           if-no-files-found: ignore
   integration:
-    name: Integration and browser
+    name: Integration tests
+    needs: changes
+    if: needs.changes.outputs.code == 'true'
     runs-on: ubuntu-24.04
-    timeout-minutes: 20
+    timeout-minutes: 15
     env:
-      # where the run's own herdr keeps its config and state (scripts/check.ts): kept, for the failure logs
       CHECK_DIR: ${{ github.workspace }}/.ci
     steps:
       - uses: actions/checkout@v7
@@ -102,21 +134,129 @@ jobs:
           chmod +x "$RUNNER_TEMP/herdr-bin/herdr"
           echo "$RUNNER_TEMP/herdr-bin" >> "$GITHUB_PATH"
       - run: bun install --frozen-lockfile
-      # A build, then the two lanes side by side on a herdr of the run's own, which it stops when
-      # it ends. The lanes share nothing: the integration files run on herdr sessions of their own.
-      - name: Integration tests (updater restart and rollback included) beside the browser regressions
-        run: bun run check integration browser
+      - name: Integration tests (updater restart and rollback included)
+        run: bun run check integration
       - name: Preserve check report and verification logs
         if: always()
         uses: actions/upload-artifact@v7
         with:
-          name: herdr-logs-${{ github.run_id }}-${{ github.run_attempt }}
+          name: integration-logs-${{ github.run_id }}-${{ github.run_attempt }}
           path: |
             .ci/report.json
             .ci/**/*.log
             .ci/config/herdr/sessions/*/test-server.log
+          include-hidden-files: true
+          if-no-files-found: ignore
+  browser-main:
+    name: Browser regression (ui-regression)
+    needs: changes
+    if: needs.changes.outputs.code == 'true'
+    runs-on: ubuntu-24.04
+    timeout-minutes: 15
+    env:
+      CHECK_DIR: ${{ github.workspace }}/.ci
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ github.sha }}
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.4.2
+      - uses: actions/setup-node@v7
+        with:
+          node-version: '22'
+      - name: Install checksum-pinned herdr 0.9.3
+        run: |
+          mkdir -p "$RUNNER_TEMP/herdr-bin"
+          curl --fail --location --retry 3 https://github.com/herdrdev/herdr/releases/download/v0.9.3/herdr-linux-x86_64 -o "$RUNNER_TEMP/herdr-bin/herdr"
+          echo "18a8dc65f1c2fa485884344356dea1cfd911c6f06cf46fa78e193f4087f4dba7  $RUNNER_TEMP/herdr-bin/herdr" | sha256sum --check
+          chmod +x "$RUNNER_TEMP/herdr-bin/herdr"
+          echo "$RUNNER_TEMP/herdr-bin" >> "$GITHUB_PATH"
+      - run: bun install --frozen-lockfile
+      - run: bun run build
+      - name: Browser regression (ui-regression.ts)
+        env:
+          BROWSER_SCRIPTS: scripts/ui-regression.ts
+        run: bun scripts/ci-browser-parallel.ts
+      - name: Preserve browser logs and evidence
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: browser-main-${{ github.run_id }}-${{ github.run_attempt }}
+          path: |
+            .ci/browser-logs/**
             .ci/browser-evidence/**/*.png
             .ci/browser-evidence/**/*.json
             .ci/browser-evidence/**/*.zip
           include-hidden-files: true
           if-no-files-found: ignore
+  browser-other:
+    name: Browser regression (other scripts)
+    needs: changes
+    if: needs.changes.outputs.code == 'true'
+    runs-on: ubuntu-24.04
+    timeout-minutes: 15
+    env:
+      CHECK_DIR: ${{ github.workspace }}/.ci
+      BROWSER_WORKERS: 4
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ github.sha }}
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.4.2
+      - uses: actions/setup-node@v7
+        with:
+          node-version: '22'
+      - name: Install checksum-pinned herdr 0.9.3
+        run: |
+          mkdir -p "$RUNNER_TEMP/herdr-bin"
+          curl --fail --location --retry 3 https://github.com/herdrdev/herdr/releases/download/v0.9.3/herdr-linux-x86_64 -o "$RUNNER_TEMP/herdr-bin/herdr"
+          echo "18a8dc65f1c2fa485884344356dea1cfd911c6f06cf46fa78e193f4087f4dba7  $RUNNER_TEMP/herdr-bin/herdr" | sha256sum --check
+          chmod +x "$RUNNER_TEMP/herdr-bin/herdr"
+          echo "$RUNNER_TEMP/herdr-bin" >> "$GITHUB_PATH"
+      - run: bun install --frozen-lockfile
+      - run: bun run build
+      - name: Browser regression (parallel)
+        env:
+          # Every script of scripts/ci-browser.sh except the one browser-main runs.
+          BROWSER_EXCLUDE: scripts/ui-regression.ts
+        run: bun scripts/ci-browser-parallel.ts
+      - name: Preserve browser logs and evidence
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: browser-other-${{ github.run_id }}-${{ github.run_attempt }}
+          path: |
+            .ci/browser-logs/**
+            .ci/browser-evidence/**/*.png
+            .ci/browser-evidence/**/*.json
+            .ci/browser-evidence/**/*.zip
+          include-hidden-files: true
+          if-no-files-found: ignore
+  integration-browser:
+    name: Integration and browser
+    needs: [changes, integration, browser-main, browser-other]
+    if: always()
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Check results
+        run: |
+          if [ "${{ needs.changes.outputs.code }}" = "false" ]; then
+            echo "Skipped: only documentation changes"
+            exit 0
+          fi
+          if [ "${{ needs.integration.result }}" != "success" ]; then
+            echo "Integration tests failed"
+            exit 1
+          fi
+          if [ "${{ needs.browser-main.result }}" != "success" ]; then
+            echo "Browser regression (ui-regression) failed"
+            exit 1
+          fi
+          if [ "${{ needs.browser-other.result }}" != "success" ]; then
+            echo "Browser regression (other scripts) failed"
+            exit 1
+          fi
+          echo "All tests passed"
diff --git a/docs/development.md b/docs/development.md
index 45c92691b8..04d1771105 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -398,20 +398,35 @@ The [CI workflow](../.github/workflows/ci.yml) runs on every PR and `main` push:
   (checksum-pinned actionlint), generated type freshness, application and critical-tools typechecks
   (`tsconfig.tools.json`), build, and
   `bun run test:unit`. This suite does not start herdr.
-- **Integration and browser**: checksum-pinned herdr 0.9.3, Node 22, then
-  `bun run check integration browser`: a build, `bun run test:integration`, and the browser
-  scripts of `scripts/ci-browser.sh` with the lockfile's Chromium, on a herdr of the run's own
-  ([Checks](#checks)). The two lanes run at the same time (`scripts/ci-lanes.ts`). The
-  integration files can run a few at a time, each worker on a herdr session of its own
-  (`scripts/ci-tests.ts`); they run one by one (`HERDR_TEST_SHARDS`, default 1 in
-  `scripts/check.ts`) until the timing-bound contract tests hold under load.
-  Missing herdr fails the run. Its herdr servers are stopped even on failure.
-  Integration tests have a 15-second default timeout so their bounded process-startup
-  probes can finish; individual tests can still specify a longer timeout.
-
-The browser lane prints each script's wall seconds and exit code, including the shared demo
-build, then a summary on success or failure. The first failing script stops the lane.
-Under `CI` or with `CHECK_DIR` set, it creates `UI_EVIDENCE_DIR` at
+- **Integration and browser**: a summary job that fails when any of three jobs fails, each with
+  checksum-pinned herdr 0.9.3, Node 22 and the lockfile's Chromium:
+  - **Integration tests** runs `bun run check integration`: a build and
+    `bun run test:integration` on a herdr of the run's own ([Checks](#checks)). The
+    integration files can run a few at a time, each worker on a herdr session of its own
+    (`scripts/ci-tests.ts`); they run one by one (`HERDR_TEST_SHARDS`, default 1 in
+    `scripts/check.ts`) until the timing-bound contract tests hold under load.
+    Missing herdr fails the run. Its herdr servers are stopped even on failure.
+    Integration tests have a 15-second default timeout so their bounded process-startup
+    probes can finish; individual tests can still specify a longer timeout.
+  - **Browser regression (ui-regression)** runs `scripts/ui-regression.ts` alone.
+  - **Browser regression (other scripts)** runs every other browser script, four at a time.
+
+  Both browser jobs run `scripts/ci-browser-parallel.ts`, which takes its script list from
+  `scripts/ci-browser.sh` (`BROWSER_SCRIPTS` picks from it, `BROWSER_EXCLUDE` leaves scripts out,
+  and a name the list does not hold is an error). `scripts/pages-gate.test.ts` fails if the two
+  jobs together do not run that list exactly once. A new browser script therefore only needs its
+  `run_script` line in `scripts/ci-browser.sh`.
+
+`bun run check browser` and `bun run check full` still run the serial lane, `scripts/ci-browser.sh`
+(`BROWSER_PARALLEL=1` hands it to the parallel runner).
+The serial lane prints each script's wall seconds and exit code, including the shared demo
+build, then a summary on success or failure. The first failing script stops it.
+The parallel runner builds the demo once, prints a line when each script starts and ends (and
+every minute a script is still running), and keeps running the other scripts after one fails.
+Each script's full output goes to `${CHECK_DIR:-.ci}/browser-logs/<script>.log`, with
+`summary.json` beside it; a failure prints the last 400 lines of its log and the log's path, and
+the job then fails. CI uploads `browser-logs` with the evidence on success or failure.
+Under `CI` or with `CHECK_DIR` set, both runners create `UI_EVIDENCE_DIR` at
 `${CHECK_DIR:-.ci}/browser-evidence`. Only the existing sticky-modifier and file-viewer captures
 are enabled automatically: the UI suite and key-bar demo have evidence branches that add
 assertions, viewport changes or font waits, so those remain disabled in the lane. Outside
diff --git a/scripts/ci-browser-parallel.ts b/scripts/ci-browser-parallel.ts
new file mode 100644
index 0000000000..728306c3ef
--- /dev/null
+++ b/scripts/ci-browser-parallel.ts
@@ -0,0 +1,189 @@
+/**
+ * Parallel browser lane: runs browser regression scripts concurrently with a worker pool.
+ * Workers are isolated by temp dir and evidence subdirectory. The demo build is shared read-only.
+ * The script list is read from scripts/ci-browser.sh, the serial lane, so the two cannot drift.
+ * Every script's full output goes to <CHECK_DIR or .ci>/browser-logs/<script>.log.
+ *
+ * BROWSER_WORKERS: worker count (default: min(cores/2, 6))
+ * BROWSER_SCRIPTS: comma-separated list of scripts to run (default: all from ci-browser.sh)
+ * BROWSER_EXCLUDE: comma-separated list of scripts to leave out of that list
+ */
+import { availableParallelism } from "node:os";
+import { basename, join } from "node:path";
+import { closeSync, mkdirSync, mkdtempSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+
+const repo = join(import.meta.dir, "..");
+const FAILURE_TAIL_LINES = 400;
+const HEARTBEAT_MS = 60_000;
+
+/** The scripts the serial lane runs, in its order (the demo build, which takes an argument, is not one). */
+export function serialBrowserScripts(source = readFileSync(join(repo, "scripts/ci-browser.sh"), "utf8")): string[] {
+  return [...source.matchAll(/^run_script (scripts\/[\w.-]+\.ts)\s*$/gm)].map((match) => match[1]!);
+}
+
+const list = (value: string | undefined): string[] => (value ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+
+/** Applies BROWSER_SCRIPTS and BROWSER_EXCLUDE to the serial list; a name it does not hold is an error. */
+export function selectBrowserScripts(all: string[], include?: string, exclude?: string): string[] {
+  const included = include?.trim() ? list(include) : all;
+  const excluded = list(exclude);
+  const unknown = [...included, ...excluded].filter((script) => !all.includes(script));
+  if (unknown.length > 0) throw new Error(`Not in scripts/ci-browser.sh: ${[...new Set(unknown)].join(", ")}`);
+  return [...new Set(included)].filter((script) => !excluded.includes(script));
+}
+
+interface ScriptResult {
+  script: string;
+  seconds: number;
+  code: number;
+  log: string;
+}
+
+async function installChromium(): Promise<string> {
+  const cli = join(repo, "node_modules/playwright-core/cli.js");
+  if (process.env.CI) {
+    console.log("[setup] Installing Chromium system dependencies...");
+    const deps = Bun.spawnSync(["sudo", "bash", "scripts/ci-bounded-retry.sh", "300", Bun.which("bun") ?? "bun", cli, "install-deps", "chromium"], { cwd: repo, stdio: ["ignore", "inherit", "inherit"] });
+    if (deps.exitCode !== 0) throw new Error("Failed to install Chromium system dependencies");
+  }
+  console.log("[setup] Installing Chromium browser...");
+  const install = Bun.spawnSync(["bun", cli, "install", "chromium"], { cwd: repo, stdio: ["ignore", "inherit", "inherit"] });
+  if (install.exitCode !== 0) throw new Error("Failed to install Chromium");
+  const path = Bun.spawnSync(["bun", "-e", 'console.log(require("playwright-core").chromium.executablePath())'], { cwd: repo });
+  return new TextDecoder().decode(path.stdout).trim();
+}
+
+async function buildDemo(dir: string): Promise<void> {
+  console.log("[setup] Building demo app...");
+  const started = Date.now();
+  const child = Bun.spawn(["bun", "scripts/demo-build.ts", dir], { cwd: repo, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, code] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+  if (code !== 0) throw new Error(`Demo build failed:\n${stdout}\n${stderr}`);
+  console.log(`[setup] Demo build completed in ${((Date.now() - started) / 1000).toFixed(1)}s`);
+}
+
+async function runScript(script: string, env: Record<string, string>, log: string): Promise<ScriptResult> {
+  const started = Date.now();
+  const fd = openSync(log, "w");
+  try {
+    const child = Bun.spawn(["bun", script], {
+      cwd: repo,
+      env: { ...process.env, ...env },
+      stdin: "ignore",
+      stdout: fd,
+      stderr: fd,
+    });
+    // A hung script shows up as a repeated line instead of silence.
+    const heartbeat = setInterval(() => {
+      console.log(`[running] ${script} (${Math.round((Date.now() - started) / 1000)}s, log ${log})`);
+    }, HEARTBEAT_MS);
+    const code = await child.exited.finally(() => clearInterval(heartbeat));
+    return { script, seconds: (Date.now() - started) / 1000, code, log };
+  } finally {
+    closeSync(fd);
+  }
+}
+
+async function main(): Promise<void> {
+  const startedAt = Date.now();
+  const scripts = selectBrowserScripts(serialBrowserScripts(), process.env.BROWSER_SCRIPTS, process.env.BROWSER_EXCLUDE);
+  if (scripts.length === 0) throw new Error("No browser scripts selected");
+
+  const requested = Number(process.env.BROWSER_WORKERS);
+  const workers = Math.max(1, Math.min(
+    requested >= 1 ? Math.floor(requested) : Math.min(Math.floor(availableParallelism() / 2), 6),
+    scripts.length
+  ));
+  const logDir = join(process.env.CHECK_DIR || ".ci", "browser-logs");
+  mkdirSync(logDir, { recursive: true });
+
+  console.log(`Browser lane: ${scripts.length} scripts, ${workers} workers, logs in ${logDir}`);
+
+  const chromePath = process.env.CHROME_PATH ?? await installChromium();
+  const demoBuild = mkdtempSync(join(tmpdir(), "herdr-demo-parallel-"));
+  await buildDemo(demoBuild);
+
+  const checkDir = process.env.CHECK_DIR;
+  const baseEvidenceDir = checkDir ? join(checkDir, "browser-evidence") : process.env.CI ? ".ci/browser-evidence" : undefined;
+  if (baseEvidenceDir) mkdirSync(baseEvidenceDir, { recursive: true });
+
+  const queue = [...scripts];
+  const results: ScriptResult[] = [];
+  const lock = { active: 0 };
+
+  async function work(workerId: number): Promise<void> {
+    while (queue.length > 0) {
+      const script = queue.shift();
+      if (!script) break;
+      lock.active++;
+      const scriptName = basename(script, ".ts");
+      const evidenceDir = baseEvidenceDir ? join(baseEvidenceDir, scriptName) : undefined;
+      if (evidenceDir) mkdirSync(evidenceDir, { recursive: true });
+
+      const shouldDisableEvidence = baseEvidenceDir && (script === "scripts/ui-regression.ts" || script === "scripts/key-bar-customization-demo-regression.ts");
+
+      const log = join(logDir, `${scriptName}.log`);
+      console.log(`[worker-${workerId}] START ${script}`);
+      const result = await runScript(script, {
+        CHROME_PATH: chromePath,
+        HERDR_DEMO_BUILD: demoBuild,
+        UI_EVIDENCE_DIR: shouldDisableEvidence ? "" : (evidenceDir ?? ""),
+        CHECK_BROWSER_EVIDENCE_DIR: evidenceDir ?? "",
+      }, log);
+      results.push(result);
+      const failure = result.code === 0 ? "" : ` exit=${result.code}, log ${log}`;
+      console.log(`[worker-${workerId}] ${result.code === 0 ? "PASS" : "FAIL"} ${script} (${result.seconds.toFixed(1)}s)${failure}`);
+      lock.active--;
+    }
+  }
+
+  await Promise.all(Array.from({ length: workers }, (_, i) => work(i)));
+
+  rmSync(demoBuild, { recursive: true, force: true });
+
+  console.log("\n" + "=".repeat(80));
+  console.log("Browser script summary");
+  console.log("=".repeat(80));
+  console.log(String.prototype.padEnd.call("script", 60) + String.prototype.padStart.call("seconds", 8) + String.prototype.padStart.call("exit", 6));
+  console.log("-".repeat(80));
+
+  const ordered = scripts.map((s) => results.find((r) => r.script === s)!).filter(Boolean);
+  for (const result of ordered) {
+    const status = result.code === 0 ? " " : "!";
+    console.log(`${status}${result.script.padEnd(59)}${result.seconds.toFixed(1).padStart(8)}${String(result.code).padStart(6)}`);
+  }
+
+  const totalSeconds = (Date.now() - startedAt) / 1000;
+  const passed = results.filter((r) => r.code === 0).length;
+  const failed = results.filter((r) => r.code !== 0);
+
+  console.log("-".repeat(80));
+  console.log(`Total: ${passed}/${results.length} passed in ${totalSeconds.toFixed(1)}s with ${workers} workers`);
+
+  writeFileSync(join(logDir, "summary.json"), JSON.stringify({
+    workers,
+    seconds: totalSeconds,
+    passed,
+    total: results.length,
+    scripts: ordered.map(({ script, seconds, code, log }) => ({ script, seconds, code, log })),
+  }, null, 2) + "\n");
+
+  for (const result of failed) {
+    const lines = readFileSync(result.log, "utf8").split("\n");
+    const shown = lines.slice(-FAILURE_TAIL_LINES);
+    console.log(`\n${"=".repeat(80)}\nFAILED ${result.script} (exit ${result.code}), full log: ${result.log}`);
+    if (shown.length < lines.length) console.log(`(last ${shown.length} of ${lines.length} lines)`);
+    console.log("=".repeat(80));
+    console.log(shown.join("\n"));
+  }
+
+  process.exit(failed.length > 0 ? 1 : 0);
+}
+
+if (import.meta.main) {
+  main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
diff --git a/scripts/ci-browser.sh b/scripts/ci-browser.sh
index 048a31e1e4..9b30ec9c6d 100644
--- a/scripts/ci-browser.sh
+++ b/scripts/ci-browser.sh
@@ -1,6 +1,12 @@
 #!/usr/bin/env bash
 # The browser lane of CI: the lockfile's Playwright Chromium, then the scripts that drive it.
+# BROWSER_PARALLEL=1: run scripts concurrently (see ci-browser-parallel.ts)
+# BROWSER_WORKERS: worker count for parallel mode (default: min(cores/2, 6))
 set -euo pipefail
+
+if [ "${BROWSER_PARALLEL:-}" = "1" ]; then
+  exec bun scripts/ci-browser-parallel.ts
+fi
 timings=""
 HERDR_DEMO_BUILD=""
 finish() {
diff --git a/scripts/pages-gate.test.ts b/scripts/pages-gate.test.ts
index c00ae3b3f0..f7aa4e3993 100644
--- a/scripts/pages-gate.test.ts
+++ b/scripts/pages-gate.test.ts
@@ -3,6 +3,7 @@ import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { selectBrowserScripts, serialBrowserScripts } from "./ci-browser-parallel.ts";
 
 const pages = readFileSync(new URL("../.github/workflows/pages.yml", import.meta.url), "utf8");
 const ci = readFileSync(new URL("../.github/workflows/ci.yml", import.meta.url), "utf8");
@@ -45,7 +46,7 @@ describe("Pages deployment gate", () => {
     expect(ci).toMatch(/group: validation-/);
     expect(pageJob("validate")).toContain("permissions:\n      contents: read");
     expect(pageJob("build")).toContain("ref: ${{ github.sha }}");
-    for (const name of ["windows-install", "fast", "integration"]) {
+    for (const name of ["windows-install", "fast", "integration", "browser-main", "browser-other"]) {
       expect(ciJob(name)).toContain("ref: ${{ github.sha }}");
     }
   });
@@ -69,19 +70,60 @@ describe("Pages deployment gate", () => {
     expect(deploy).toContain("${{ needs.build.outputs.sha }}");
   });
 
-  it("keeps reports and nested verification evidence for both CI jobs on success or failure", () => {
+  it("keeps reports and nested verification evidence for CI jobs on success or failure", () => {
     expect(ciJob("fast")).toContain("CHECK_DIR: ${{ github.workspace }}/.ci");
     expect(ciJob("integration")).toContain("CHECK_DIR: ${{ github.workspace }}/.ci");
-    for (const name of ["fast", "integration"]) {
+    const fast = ciJob("fast");
+    expect(fast).toContain(".ci/report.json");
+    expect(fast).toContain("if: always()");
+    expect(fast).toContain(".ci/**/*.log");
+    expect(fast).toContain(".ci/browser-evidence/**/*.png");
+    expect(fast).toContain(".ci/browser-evidence/**/*.json");
+    expect(fast).toContain(".ci/browser-evidence/**/*.zip");
+    const integration = ciJob("integration");
+    expect(integration).toContain(".ci/report.json");
+    expect(integration).toContain("if: always()");
+    expect(integration).toContain(".ci/**/*.log");
+    expect(integration).toContain(".ci/config/herdr/sessions/*/test-server.log");
+    for (const name of ["browser-main", "browser-other"]) {
       const job = ciJob(name);
-      expect(job).toContain(".ci/report.json");
       expect(job).toContain("if: always()");
-      expect(job).toContain(".ci/**/*.log");
+      expect(job).toContain(".ci/browser-logs/**");
       expect(job).toContain(".ci/browser-evidence/**/*.png");
       expect(job).toContain(".ci/browser-evidence/**/*.json");
       expect(job).toContain(".ci/browser-evidence/**/*.zip");
     }
-    expect(ciJob("integration")).toContain(".ci/config/herdr/sessions/*/test-server.log");
+  });
+});
+
+describe("Browser lane script lists", () => {
+  const serial = serialBrowserScripts();
+  const env = (job: string, name: string) => job.match(new RegExp(`^\\s+${name}: (.+)$`, "m"))?.[1];
+
+  it("reads every script the serial lane runs, and only those", () => {
+    const sh = readFileSync(new URL("./ci-browser.sh", import.meta.url), "utf8");
+    const runs = [...sh.matchAll(/^run_script (\S+)/gm)].map((match) => match[1]).filter((script) => script !== "scripts/demo-build.ts");
+    expect(serial).toEqual(runs);
+    expect(serial).toContain("scripts/ui-regression.ts");
+    expect(serial).toContain("scripts/sidebar-spacing-demo-regression.ts");
+    expect(new Set(serial).size).toBe(serial.length);
+  });
+
+  it("splits the serial lane across the CI browser jobs with nothing dropped or run twice", () => {
+    const shards = ["browser-main", "browser-other"].map((name) => {
+      const job = ciJob(name);
+      expect(job).toContain("run: bun scripts/ci-browser-parallel.ts");
+      return selectBrowserScripts(serial, env(job, "BROWSER_SCRIPTS"), env(job, "BROWSER_EXCLUDE"));
+    });
+    const all = shards.flat();
+    expect(all.length).toBe(serial.length);
+    expect([...all].sort()).toEqual([...serial].sort());
+  });
+
+  it("refuses a script name the serial lane does not run", () => {
+    expect(() => selectBrowserScripts(serial, "scripts/missing-regression.ts")).toThrow("scripts/missing-regression.ts");
+    expect(() => selectBrowserScripts(serial, undefined, "scripts/missing-regression.ts")).toThrow("scripts/missing-regression.ts");
+    expect(selectBrowserScripts(serial, undefined, "scripts/ui-regression.ts")).toEqual(serial.filter((script) => script !== "scripts/ui-regression.ts"));
   });
 });