@@ -30,6 +30,11 @@ on:
           - "5.1"
           - "4.5"
         default: "5.2"
+      sweep:
+        description: Also run the full showcase falsifier sweep (5.2, sharded)
+        required: false
+        type: boolean
+        default: false
   schedule:
     - cron: "0 7 * * 1"   # weekly, Monday 07:00 UTC
   push:
@@ -391,17 +396,130 @@ jobs:
             --xvfb \
             --catalog tests/smoke/catalog.json
 
-      - name: Full showcase falsifier sweep (weekly, 5.2)
-        # The catalog runs one falsifier per row on every smoke run. The weekly
-        # cron also runs every falsifier in every showcase README table and
-        # asserts each lands on the exit it declares (~5 min).
-        if: ${{ github.event_name == 'schedule' && matrix.series == '5.2' }}
-        run: |
-          set -euo pipefail
-          python3 tests/check_falsifier_targets.py --run "$BLENDER"
-
       - name: Smoke summary
         if: ${{ always() && env.BLENDER != '' }}
         run: |
           set -euo pipefail
           python3 tests/smoke/summarize.py --status "$BDT_SMOKE_STATUS"
+
+  showcase-sweep:
+    # The catalog runs one falsifier per row on every smoke run. The weekly
+    # cron also runs every falsifier in every showcase README table and asserts
+    # each lands on the exit it declares. At 80 pieces / 800+ falsifiers one
+    # serial sweep no longer fit beside the happy paths in the smoke job's 75
+    # minutes (cancelled on 2026-10-12, #482), so it is its own job, fanned out
+    # over four jobs by piece (check_falsifier_targets.py --shard K/N).
+    name: Showcase falsifier sweep ${{ matrix.shard }}/4 (5.2)
+    if: github.event_name == 'schedule' || (github.event_name == 'workflow_dispatch' && inputs.sweep)
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [0, 1, 2, 3]  # N is 4: keep the "/4" in the job name and the run step in step
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+
+      - name: Install Blender runtime libraries
+        run: |
+          set -euo pipefail
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            xvfb libgl1 libegl1 libxrender1 libxxf86vm1 libxfixes3 libxi6 \
+            libxkbcommon0 libsm6 libice6
+
+      - name: Resolve Blender 5.2
+        id: resolve
+        run: |
+          set -euo pipefail
+          base="https://download.blender.org/release/Blender5.2/"
+          file=$(curl -fsSL "$base" \
+            | grep -oE "blender-5\.2\.[0-9]+-linux-x64\.tar\.xz" \
+            | sort -V | uniq | tail -1)
+          if [ -z "$file" ]; then
+            echo "::error::Could not resolve a linux-x64 build for Blender 5.2 at $base"
+            exit 1
+          fi
+          version="${file#blender-}"
+          version="${version%-linux-x64.tar.xz}"
+          echo "base=$base" >> "$GITHUB_OUTPUT"
+          echo "file=$file" >> "$GITHUB_OUTPUT"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+
+      - name: Restore Blender ${{ steps.resolve.outputs.version }} from cache
+        id: bl-cache
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: ${{ runner.temp }}/bl
+          key: blender-${{ steps.resolve.outputs.version }}-linux-x64
+
+      - name: Download Blender and verify its published sha256
+        if: steps.bl-cache.outputs.cache-hit != 'true'
+        run: |
+          set -euo pipefail
+          base="${{ steps.resolve.outputs.base }}"
+          file="${{ steps.resolve.outputs.file }}"
+          version="${{ steps.resolve.outputs.version }}"
+          mkdir -p "$RUNNER_TEMP/bl"
+          curl -fSL --retry 3 -o "$RUNNER_TEMP/bl.tar.xz" "${base}${file}"
+          curl -fsSL --retry 3 -o "$RUNNER_TEMP/bl.sha256" "${base}blender-${version}.sha256"
+          expected=$(grep -E "  ${file}$" "$RUNNER_TEMP/bl.sha256" | awk '{print $1}')
+          if [ -z "$expected" ]; then
+            echo "::error::no published sha256 for ${file}"
+            exit 1
+          fi
+          echo "${expected}  $RUNNER_TEMP/bl.tar.xz" | sha256sum -c - \
+            || { echo "::error::sha256 mismatch for ${file}; refusing to extract"; exit 1; }
+          tar -xf "$RUNNER_TEMP/bl.tar.xz" -C "$RUNNER_TEMP/bl"
+
+      - name: Locate Blender binary
+        run: |
+          set -euo pipefail
+          bl=$(find "$RUNNER_TEMP/bl" -maxdepth 2 -type f -name blender | head -1)
+          if [ -z "$bl" ]; then
+            echo "::error::blender binary not found"
+            exit 1
+          fi
+          "$bl" --version | head -1
+          echo "BLENDER=$bl" >> "$GITHUB_ENV"
+
+      - name: Run shard ${{ matrix.shard }}/4
+        run: |
+          set -euo pipefail
+          python3 tests/check_falsifier_targets.py --run "$BLENDER" --shard "${{ matrix.shard }}/4"
+
+  report-scheduled-failure:
+    # A red or cancelled weekly run used to go unnoticed (#482): open an issue,
+    # or comment on the one already open, so the cron is never silently red.
+    name: Report a failed weekly run
+    needs: [smoke, showcase-sweep]
+    if: >-
+      always() && github.event_name == 'schedule' &&
+      (contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled'))
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      issues: write
+    steps:
+      - name: Open or update the tracking issue
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          SMOKE: ${{ needs.smoke.result }}
+          SWEEP: ${{ needs.showcase-sweep.result }}
+        run: |
+          set -euo pipefail
+          title="Weekly Blender smoke run failed"
+          body="Scheduled run: $RUN_URL
+          - smoke matrix: \`$SMOKE\`
+          - showcase falsifier sweep: \`$SWEEP\`
+
+          Opened by blender-smoke.yml (report-scheduled-failure). Close it once a weekly run is green."
+          num=$(gh issue list --state open --search "\"$title\" in:title" --json number --jq '.[0].number // empty')
+          if [ -n "$num" ]; then
+            gh issue comment "$num" --body "$body"
+            echo "commented on #$num"
+          else
+            gh issue create --title "$title" --body "$body" --label "bug,ci,priority: high"
+          fi
@@ -438,6 +438,9 @@ jobs:
       - name: Exit-code gate resolves fail() helpers and tuple returns
         run: python3 tests/test_exit_code_readme.py -v
 
+      - name: Showcase falsifier sweep shards cover every piece once
+        run: python3 tests/test_falsifier_shard.py -v
+
       - name: Hero-drift tool exit-code tests
         run: |
           pip install -r requirements-dev.txt
 
@@ -189,7 +189,9 @@ The host runner is `tests/smoke/run_example.py`. Shipped examples are listed in
   `run_catalog.py` runs each after the row's happy path; it passes only on
   exactly that exit. `tests/check_smoke_catalog.py` rejects a row without one
   and any unknown key. The weekly cron also runs the full showcase sweep
-  (`tests/check_falsifier_targets.py --run`).
+  (`tests/check_falsifier_targets.py --run --shard K/4`, four jobs; dispatch
+  with `sweep: true` to run it by hand), and a red or cancelled weekly run
+  opens or comments on a "Weekly Blender smoke run failed" issue.
 - **Summary:** `tests/smoke/summarize.py` prints passed/skipped/failed. Zero
   PASSes makes the job red even if every example skipped cleanly. Falsifier
   runs are tabled separately and never count toward that PASS.
 
@@ -33,7 +33,11 @@
 falsifier tripping an earlier check. It costs one Blender launch per
 falsifier: measured at 276 s for the whole showcase tree on one version
 (160 falsifiers, 25 pieces, Blender 5.2.1). That is an authoring and cron
-tool, not a per-PR smoke step.
+tool, not a per-PR smoke step. At 80 pieces and 800+ falsifiers one serial
+sweep outgrew the smoke job's budget (#482), so ``--shard K/N`` runs only
+every N-th piece starting at K (0-based, sorted by name), and the weekly cron
+fans the sweep out across N jobs. Each run prints its wall time so the slow
+pieces are visible.
 
 Exit codes: 0 clean, 1 a mapping disagrees, 2 usage.
 """
@@ -46,6 +50,7 @@
 import re
 import subprocess
 import sys
+import time
 
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 SHOWCASE = os.path.join(ROOT, "showcase")
@@ -222,14 +227,32 @@ def check_static():
 RUN_TIMEOUT = 900  # seconds per Blender run, matching tests/smoke/run_example.py
 
 
-def check_runtime(blender, only=None):
+def parse_shard(text):
+    """'K/N' -> (K, N) with 0 <= K < N; argparse-friendly."""
+    try:
+        k, n = (int(x) for x in text.split("/"))
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"--shard wants K/N, got {text!r}")
+    if n < 1 or not 0 <= k < n:
+        raise argparse.ArgumentTypeError(f"--shard {text!r}: need 0 <= K < N")
+    return k, n
+
+
+def in_shard(index, shard):
+    return shard is None or index % shard[1] == shard[0]
+
+
+def check_runtime(blender, only=None, shard=None):
     failures, checked = [], 0
-    for name, readme, script in piece_paths():
+    for index, (name, readme, script) in enumerate(piece_paths()):
         if only and name not in only:
             continue
+        if not in_shard(index, shard):
+            continue
         falsifiers, _exits = parse_readme(readme)
         for flag, (want, _target) in sorted(falsifiers.items()):
             checked += 1
+            started = time.monotonic()
             try:
                 proc = subprocess.run(
                     [blender, "--background", "--python-exit-code", "1", "--python", script,
@@ -243,7 +266,9 @@ def check_runtime(blender, only=None):
                 # one hang cannot stall the weekly sweep.
                 got = f"timeout after {RUN_TIMEOUT}s"
             status = "ok" if got == want else "MISMATCH"
-            print(f"  {status:9} {name} {flag}: want {want}, got {got}")
+            secs = time.monotonic() - started
+            print(f"  {status:9} {name} {flag}: want {want}, got {got} ({secs:.0f}s)",
+                  flush=True)
             if got != want:
                 failures.append(
                     (name, f"{flag} declared exit {want} but exited {got}")
@@ -257,6 +282,8 @@ def main(argv=None):
                    help="also execute each falsifier with this Blender binary")
     p.add_argument("--only", action="append", default=None,
                    help="limit the runtime mode to these piece names")
+    p.add_argument("--shard", type=parse_shard, default=None, metavar="K/N",
+                   help="runtime mode: only every N-th piece, starting at K (0-based)")
     args = p.parse_args(argv)
 
     failures, undocumented, checked, pieces, skipped = check_static()
@@ -271,8 +298,10 @@ def main(argv=None):
         )
 
     if args.run:
-        print(f"runtime falsifier sweep with {args.run}")
-        rt_failures, rt_checked = check_runtime(args.run, set(args.only or []) or None)
+        shard = f" (shard {args.shard[0]}/{args.shard[1]})" if args.shard else ""
+        print(f"runtime falsifier sweep with {args.run}{shard}", flush=True)
+        rt_failures, rt_checked = check_runtime(args.run, set(args.only or []) or None,
+                                                args.shard)
         failures.extend(rt_failures)
         checked += rt_checked
 
 
@@ -0,0 +1,38 @@
+"""Tests for tests/check_falsifier_targets.py --shard (the weekly sweep fan-out, #482).
+
+Run: python tests/test_falsifier_shard.py -v
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import check_falsifier_targets as cft  # noqa: E402
+
+
+class ShardTest(unittest.TestCase):
+    def test_shards_partition_every_piece_exactly_once(self):
+        pieces = [name for name, _r, _s in cft.piece_paths()]
+        self.assertGreater(len(pieces), 0)
+        for n in (1, 2, 4, 7):
+            seen = []
+            for k in range(n):
+                seen += [p for i, p in enumerate(pieces) if cft.in_shard(i, (k, n))]
+            self.assertEqual(sorted(seen), sorted(pieces), f"N={n}")
+
+    def test_no_shard_keeps_everything(self):
+        self.assertTrue(all(cft.in_shard(i, None) for i in range(10)))
+
+    def test_parse_shard(self):
+        self.assertEqual(cft.parse_shard("0/4"), (0, 4))
+        self.assertEqual(cft.parse_shard("3/4"), (3, 4))
+        for bad in ("4/4", "-1/4", "1/0", "x", "1/2/3"):
+            with self.assertRaises(argparse.ArgumentTypeError, msg=bad):
+                cft.parse_shard(bad)
+
+
+if __name__ == "__main__":
+    unittest.main()