diff --git a/.cursorrules b/.cursorrules
index 529d0d757..2a9e8b015 100644
--- a/.cursorrules
+++ b/.cursorrules
@@ -208,6 +208,8 @@ rg -n "(shutil.rmtree|os.remove|Path.unlink|rm -rf|rimraf)" -S
 - "🔍 Code Quality & Security"
 - "Unit Tests (3.11)"
 - "Unit Tests (3.12)"
+- "Unit Tests md-heavy (3.11)"
+- "Unit Tests md-heavy (3.12)"
 
 ### נוספים
 - אין `paths-ignore` על `.cursorrules` – שינוי בו מריץ CI
diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index f00ae6193..22d7bf714 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -115,8 +115,10 @@ EOF
 | בדיקה | תיאור |
 |-------|--------|
 | 🔍 **Code Quality & Security** | בדיקת איכות קוד ופרצות אבטחה |
-| 🧪 **Unit Tests (3.11)** | טסטים על Python 3.11 |
-| 🧪 **Unit Tests (3.12)** | טסטים על Python 3.12 |
+| 🧪 **Unit Tests (3.11)** | כל הטסטים חוץ מ-`md_heavy`, על Python 3.11 |
+| 🧪 **Unit Tests (3.12)** | כל הטסטים חוץ מ-`md_heavy`, על Python 3.12 |
+| 🧪 **Unit Tests md-heavy (3.11)** | טסטי ה-Markdown הכבדים (`md_heavy`), על Python 3.11 |
+| 🧪 **Unit Tests md-heavy (3.12)** | טסטי ה-Markdown הכבדים (`md_heavy`), על Python 3.12 |
 
 ---
 
diff --git a/.github/agents/my-agent.agent.md b/.github/agents/my-agent.agent.md
index 7494e0c6d..edcdf897c 100644
--- a/.github/agents/my-agent.agent.md
+++ b/.github/agents/my-agent.agent.md
@@ -76,6 +76,8 @@ pull_request_template: |
   - 🔍 Code Quality & Security
   - Unit Tests (3.11)
   - Unit Tests (3.12)
+  - Unit Tests md-heavy (3.11)
+  - Unit Tests md-heavy (3.12)
 
   ## 📝 סוג שינוי
   - [ ] feat: פיצ'ר חדש
@@ -134,6 +136,8 @@ guards:
       - "🔍 Code Quality & Security"
       - "Unit Tests (3.11)"
       - "Unit Tests (3.12)"
+      - "Unit Tests md-heavy (3.11)"
+      - "Unit Tests md-heavy (3.12)"
     description: "כל ה-Required Checks חייבים להיות ירוקים"
 
 style_guide:
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index e70714a60..e17c0d452 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -14,7 +14,7 @@
   <li>סיכוני Rollback אם יש</li>
   <li>קישור ל-Docs Preview אם רלוונטי</li>
   <li>השפעה על Deploy (אם יש)</li>
-  <li>CI Required Checks: 🔍 Code Quality & Security; Unit Tests (3.11); Unit Tests (3.12)</li>
+  <li>CI Required Checks: 🔍 Code Quality & Security; Unit Tests (3.11); Unit Tests (3.12); Unit Tests md-heavy (3.11); Unit Tests md-heavy (3.12)</li>
   <li>אין סודות/PII בקוד</li>
   <li>אין מחיקות מסוכנות (ראו .cursorrules)</li>
 </ul>
@@ -44,6 +44,8 @@
 - 🔍 Code Quality & Security
 - Unit Tests (3.11)
 - Unit Tests (3.12)
+- Unit Tests md-heavy (3.11)
+- Unit Tests md-heavy (3.12)
 
 ## 📝 סוג שינוי
 - [ ] feat: פיצ'ר חדש
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index cf93722f2..fa1d561ac 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -165,20 +165,39 @@ jobs:
             });
 
   unit-tests:
-    name: "Unit Tests (${{ matrix.python-version }})"
+    # שני מסלולים לכל גרסת פייתון, שרצים במקביל. ``main`` מריץ את כל הטסטים חוץ
+    # מאלה שמסומנים ``md_heavy`` (הרישום ב-``pytest.ini``), ו-``md-heavy`` מריץ רק
+    # אותם. הם במסלול משלהם כי הם מפרסרים קלט ענק בתקרות של פרסר ה-Markdown, וכך
+    # הם אינם מאריכים את המסלול שכל PR מחכה לו. ראו docs/ci-cd.rst.
+    #
+    # כל מסלול מדווח סטטוס חובה משלו בשם ``<label> (<python-version>)``. שמות
+    # הסטטוסים כתובים גם ברשימות של בדיקות החובה בתיעוד ובתבניות, ו-
+    # ``tests/test_required_checks_are_listed.py`` משווה אותן למטריצה הזו.
+    name: "${{ matrix.label }} (${{ matrix.python-version }})"
     runs-on: ubuntu-latest
     timeout-minutes: 30
     strategy:
       fail-fast: false
       matrix:
         python-version: [ '3.11', '3.12' ]
+        suite: ['main', 'md-heavy']
+        include:
+          - suite: main
+            label: 'Unit Tests'
+            marker: 'not md_heavy'
+          - suite: md-heavy
+            label: 'Unit Tests md-heavy'
+            marker: 'md_heavy'
     services:
+      # המסלול ``md-heavy`` אינו צריך מסד: ``image`` ריק אומר ל-runner לא להרים את
+      # השירות (``jobs.<job_id>.services.<service_id>.image`` בתיעוד של GitHub
+      # Actions).
       mongodb:
         # 8.0 ולא 6.0, כי הפרודקשן רץ על MongoDB Atlas 8.0 — בדיקה שרצה מול
         # מסד אמיתי צריכה לבדוק את אותו מנוע. בפרט ``queryShapeHash`` בפלט של
         # ``explain`` קיים רק מ-8.0 ומעלה, ו-tests/test_profiler_projection_mongo.py
         # נשען עליו. ראו docs/testing.rst.
-        image: mongo:8.0
+        image: ${{ matrix.suite == 'main' && 'mongo:8.0' || '' }}
         env:
           MONGO_INITDB_ROOT_USERNAME: test
           MONGO_INITDB_ROOT_PASSWORD: test123
@@ -189,7 +208,7 @@ jobs:
           --health-timeout 5s
           --health-retries 5
       redis:
-        image: redis:7-alpine
+        image: ${{ matrix.suite == 'main' && 'redis:7-alpine' || '' }}
         # Avoid host port binding; job connects via service hostname
         options: >-
           --health-cmd "redis-cli ping"
@@ -217,6 +236,10 @@ jobs:
       - name: 🔎 Dependency integrity (pip check)
         run: pip check || true
 
+      # שם הסטטוס נבנה מהמטריצה, באותה צורה כמו ``name`` של הג'וב, כך שכל מסלול
+      # כותב רק לסטטוס שלו. GitHub קובע את מצב הסטטוס לפי הדיווח האחרון לכל שם
+      # (REST, "Commit statuses"), ולכן שני מסלולים שכותבים לאותו שם היו דורסים זה
+      # את זה — והצלחה של אחד הייתה מסתירה כשל של השני.
       - name: Report required status (pending)
         if: github.event_name == 'pull_request'
         uses: actions/github-script@v7
@@ -225,19 +248,20 @@ jobs:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
             const sha = context.payload.pull_request ? context.payload.pull_request.head.sha : context.sha;
-            const ver = process.env.PYV || '${{ matrix.python-version }}';
             await github.request('POST /repos/{owner}/{repo}/statuses/{sha}', {
               owner: context.repo.owner,
               repo: context.repo.repo,
               sha,
               state: 'pending',
-              context: `Unit Tests (${ver})`,
+              context: process.env.STATUS_CONTEXT,
               description: 'Job queued/running',
               target_url: `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`
             });
         env:
-          PYV: ${{ matrix.python-version }}
+          STATUS_CONTEXT: "${{ matrix.label }} (${{ matrix.python-version }})"
+      # בדיקת תחביר על כל הריפו — לא תלויה במסלול, ולכן רצה פעם אחת לכל גרסה.
       - name: 🧪 Smoke compile (exclude .restore)
+        if: matrix.suite == 'main'
         run: |
           find . -type f -name "*.py" -not -path "./.restore/*" -print0 | xargs -0 -n1 -P 4 python -m py_compile
       - name: 🧪 Run Tests
@@ -267,8 +291,15 @@ jobs:
           REQUESTS_RETRIES: '0'
           REQUESTS_RETRY_BACKOFF: '0'
           AIOHTTP_TIMEOUT_TOTAL: '6'
+        # ``-m`` בוחר את הטסטים של המסלול (``matrix.marker``). מסלול שלא נבחר בו אף
+        # טסט נכשל ולא עובר בשקט: pytest יוצא בקוד 5 כשלא נאסף אף טסט, גם כשכולם
+        # סוננו ב-``-m`` (נמדד ב-pytest 8.4.2, עם ``-n`` ובלעדיו). כך שם סימון ששונה
+        # כאן ולא בטסטים, או בכל הטסטים ולא כאן, מפיל את המסלול ``md-heavy``. טסט בודד
+        # שהסימון שלו חסר או שגוי פשוט רץ במסלול הרגיל. את קוד היציאה, ואת זה ששני
+        # הביטויים משלימים זה את זה, מקבע ``tests/test_required_checks_are_listed.py``.
         run: |
-          pytest -n auto --dist=loadscope -v -o addopts="" --cov=. --cov-report=xml --cov-report=term \
+          pytest -n auto --dist=loadscope -v -o addopts="" -m "${{ matrix.marker }}" \
+                 --cov=. --cov-report=xml --cov-report=term \
                  --durations=0 --json-report --json-report-file=unit-durations.json
 
       - name: Upload coverage to Codecov
@@ -285,7 +316,10 @@ jobs:
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: unit-durations-${{ matrix.python-version }}-${{ github.run_id }}
+          # שם ייחודי לכל מסלול: ``upload-artifact@v4`` אינו מאפשר שתי העלאות לאותו
+          # שם. הקידומת ``unit-durations-`` נשארת, כי ``notify-post-merge-issue.yml``
+          # מחפש לפיה את הדוחות שבהם נספרים טסטים שנכשלו.
+          name: unit-durations-${{ matrix.suite }}-${{ matrix.python-version }}-${{ github.run_id }}
           path: |
             unit-durations.json
           if-no-files-found: ignore
@@ -298,18 +332,17 @@ jobs:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
             const sha = context.payload.pull_request ? context.payload.pull_request.head.sha : context.sha;
-            const ver = process.env.PYV || '${{ matrix.python-version }}';
             await github.request('POST /repos/{owner}/{repo}/statuses/{sha}', {
               owner: context.repo.owner,
               repo: context.repo.repo,
               sha,
               state: 'success',
-              context: `Unit Tests (${ver})`,
+              context: process.env.STATUS_CONTEXT,
               description: 'Tests passed',
               target_url: `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`
             });
         env:
-          PYV: ${{ matrix.python-version }}
+          STATUS_CONTEXT: "${{ matrix.label }} (${{ matrix.python-version }})"
 
       - name: Report required status (failure)
         if: ${{ failure() }}
@@ -319,18 +352,17 @@ jobs:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
             const sha = context.payload.pull_request ? context.payload.pull_request.head.sha : context.sha;
-            const ver = process.env.PYV || '${{ matrix.python-version }}';
             await github.request('POST /repos/{owner}/{repo}/statuses/{sha}', {
               owner: context.repo.owner,
               repo: context.repo.repo,
               sha,
               state: 'failure',
-              context: `Unit Tests (${ver})`,
+              context: process.env.STATUS_CONTEXT,
               description: 'Tests failed',
               target_url: `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`
             });
         env:
-          PYV: ${{ matrix.python-version }}
+          STATUS_CONTEXT: "${{ matrix.label }} (${{ matrix.python-version }})"
 
       - name: Report required status (cancelled)
         if: ${{ cancelled() }}
@@ -340,18 +372,17 @@ jobs:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
             const sha = context.payload.pull_request ? context.payload.pull_request.head.sha : context.sha;
-            const ver = process.env.PYV || '${{ matrix.python-version }}';
             await github.request('POST /repos/{owner}/{repo}/statuses/{sha}', {
               owner: context.repo.owner,
               repo: context.repo.repo,
               sha,
               state: 'failure',
-              context: `Unit Tests (${ver})`,
+              context: process.env.STATUS_CONTEXT,
               description: 'Job cancelled',
               target_url: `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`
             });
         env:
-          PYV: ${{ matrix.python-version }}
+          STATUS_CONTEXT: "${{ matrix.label }} (${{ matrix.python-version }})"
 
   js-tests:
     name: "JS Tests (node)"
diff --git a/docs/auto-updates-and-auto-merge.md b/docs/auto-updates-and-auto-merge.md
index 80edb3f38..216096525 100644
--- a/docs/auto-updates-and-auto-merge.md
+++ b/docs/auto-updates-and-auto-merge.md
@@ -40,11 +40,7 @@
    - סמן:
      - Require a pull request before merging
      - Require status checks to pass before merging
-       - בחר את הסטטוסים שמגיעים מ־ci.yml:
-        - "Unit Tests (3.9)"
-        - "Unit Tests (3.10)"
-        - "Unit Tests (3.11)"
-         - "🔍 Code Quality & Security"
+       - בחר את הסטטוסים הנדרשים שמגיעים מ־ci.yml. הרשימה נמצאת ב-`docs/ci-cd.rst`, ולא מועתקת לכאן כדי שלא תתיישן.
        - מומלץ: Require branches to be up to date before merging
      - Require conversation resolution before merging (מומלץ)
    
@@ -86,7 +82,7 @@
 ### פתרון תקלות
 - "No checks have been added" בכללי ההגנה:
   - ודא שיש לפחות ריצה אחת של ה־CI על PR (גם Draft מספיק).
-  - רענן את העמוד ואז בחר את 4 הסטטוסים מרשימת ה־checks (Unit Tests 3 גרסאות + Code Quality).
+  - רענן את העמוד ואז בחר את הסטטוסים הנדרשים מרשימת ה־checks (הרשימה ב-`docs/ci-cd.rst`).
 
 - "There isn’t anything to compare" כשפותחים PR:
   - ודא שה־base הוא `main` וה־compare הוא הענף שלך.
@@ -100,7 +96,7 @@
   
 
 ### צ'ק־ליסט מהיר
-- [ ] הגדרת Branch protection ל־`main` עם 4 הסטטוסים מ־ci.yml
+- [ ] הגדרת Branch protection ל־`main` עם הסטטוסים הנדרשים מ־ci.yml (הרשימה ב-`docs/ci-cd.rst`)
 - [ ] הפעלת "Allow auto‑merge" (Settings → General → Pull requests)
 - [ ] הוספת Secret: `DEPENDABOT_AUTOMERGE`=true (כשרוצים אוטומרג׳ ל־patch)
 - [ ] לשקול כיבוי זמני של Auto Deploy ב־Render לפני מיזוגים ל־`main`
diff --git a/docs/branch-protection-and-pr-rules.rst b/docs/branch-protection-and-pr-rules.rst
index 09f3ef922..63b4c83b9 100644
--- a/docs/branch-protection-and-pr-rules.rst
+++ b/docs/branch-protection-and-pr-rules.rst
@@ -17,9 +17,7 @@ Branch Protection & PR Rules
 
 CI – Required Checks
 --------------------
-- "🔍 Code Quality & Security"
-- "Unit Tests (3.11)"
-- "Unit Tests (3.12)"
+- אילו סטטוסים ה-PR חייב לעבור, ומתי סטטוס חדש מתחיל לחסום מיזוג — ב-:doc:`ci-cd`. העמוד הזה מפנה לשם במקום להחזיק עותק של הרשימה.
 
 קישורים
 -------
diff --git a/docs/ci-cd.rst b/docs/ci-cd.rst
index 67b32c0eb..371cab156 100644
--- a/docs/ci-cd.rst
+++ b/docs/ci-cd.rst
@@ -16,12 +16,18 @@ CI/CD Guide
 - 🔍 Code Quality & Security
 - Unit Tests (3.11)
 - Unit Tests (3.12)
+- Unit Tests md-heavy (3.11)
+- Unit Tests md-heavy (3.12)
+
+שמות הסטטוסים של ``Unit Tests`` נבנים מהמטריצה של הג'וב ``unit-tests`` ב-``.github/workflows/ci.yml`` (``label`` ו-``python-version``). אותם שמות כתובים ביד גם בקבצים אחרים בריפו, ו-``tests/test_required_checks_are_listed.py`` משווה למטריצה כל קובץ כזה שרשום בו (``LISTS``), כולל העמוד הזה. הוא נכשל גם כשעותק מופיע בקובץ שאינו רשום בו, אלא אם הקובץ מסומן שם כתמונת מצב ולא כרשימה שפועלים לפיה (``SNAPSHOTS``). עמוד שרק צריך להזכיר את הרשימה מפנה לכאן במקום להעתיק אותה.
+
+**סטטוס חדש אינו חוסם מיזוג עד שמסמנים אותו כבדיקת חובה** בכלל שמגן על ``main`` בהגדרות של GitHub (Require status checks to pass before merging). GitHub מציע לבחירה רק בדיקה שעברה בהצלחה בריפו בשבעת הימים האחרונים (GitHub Docs, "Troubleshooting required status checks"), ולכן מסמנים אותה אחרי שה-CI של ה-PR שהוסיף אותה עבר.
 
 ריכוז CI (Overview)
 --------------------
 
 - **Code Quality & Security** – בדיקות סטטיות ואבטחה
-- **Unit Tests (3.11/3.12)** – טסטי יחידה במטריצת גרסאות
+- **Unit Tests (3.11/3.12)** ו-**Unit Tests md-heavy (3.11/3.12)** – טסטי היחידה, בשני מסלולים לכל גרסת פייתון שרצים במקביל. ``Unit Tests`` מריץ את כל הטסטים חוץ מאלה שמסומנים ``md_heavy``, ו-``Unit Tests md-heavy`` מריץ רק אותם: טסטי פרסר ה-Markdown הכבדים (ראו :doc:`testing`). כל מסלול מדווח סטטוס חובה משלו, והמסלול ``md-heavy`` אינו מרים את MongoDB ואת Redis (``services`` של ``unit-tests``).
 - **JS Tests (node)** – טסטי הצד-לקוח שב-``tests/*.test.js``. כל קובץ הוא סקריפט עצמאי שמריץ את עצמו ויוצא עם קוד שגיאה בכשל, בלי רץ טסטים חיצוני. ``repo-history.test.js`` מדולג במפורש: הוא כתוב בסגנון ``describe``/``it`` ואין בפרויקט רץ שמספק אותם. **אינו סטטוס נדרש** – הכשל מופיע ב-PR אך אינו חוסם מיזוג.
 - **Performance Tests** – טסטי ביצועים (ברירת מחדל: הכל; Draft + ``perf-light``: רק קלים). דוחות זמני ריצה נשמרים כארטיפקטים.
 
diff --git a/docs/testing.rst b/docs/testing.rst
index bf37ea941..c06eb3e48 100644
--- a/docs/testing.rst
+++ b/docs/testing.rst
@@ -221,7 +221,27 @@ Mocking HTTP ב‑github_menu_handler
 CI נתמך
 -------
 
-- ה‑PR חייב לעבור סטטוסים: "🔍 Code Quality & Security", "Unit Tests (3.11)", "Unit Tests (3.12)".
+- אילו ג'ובים רצים על PR ואילו סטטוסים הוא חייב לעבור — ב-:doc:`ci-cd`. העמוד הזה מפנה לשם במקום להחזיק עותק של הרשימה.
+
+טסטי Markdown כבדים (``md_heavy``)
+-----------------------------------
+
+**טסטים שמסומנים ``md_heavy`` רצים ב-CI במסלול משלהם, במקביל לשאר הטסטים.** אלה טסטי פרסר ה-Markdown שעיקר העבודה שלהם הוא החישוב עצמו: השוואה לאורקל cmark-gfm (``tests/test_md_parser_oracle.py``), קלט ענק בתקרות של הפרסר, והטסטים של סקריפטי המדידה (``scripts/md_parser_upgrade_zero_diff.py`` ו-``scripts/measure_md_parse_cost.py``). הסימון רשום ב-``pytest.ini``. הוא מונח על הקובץ כולו (``pytestmark``) כשכל הקובץ מהסוג הזה, ועל טסט בודד כשרק הוא כזה — כמו שני טסטי התקרה ב-``tests/test_md_parser.py``.
+
+- ``pytest`` בלי ``-m`` מריץ את כולם, כולל ``md_heavy``. כדי להריץ רק חלק אחד:
+
+  .. code-block:: bash
+
+     # רק הכבדים — מה שהמסלול md-heavy מריץ ב-CI
+     pytest -m md_heavy
+
+     # כל השאר — מה שהמסלול הרגיל מריץ ב-CI
+     pytest -m "not md_heavy"
+
+- ב-CI הג'וב ``unit-tests`` ב-``.github/workflows/ci.yml`` רץ בשני מסלולים לכל גרסת פייתון, וכל מסלול מדווח סטטוס חובה משלו (ראו :doc:`ci-cd`).
+- **מתי מסמנים טסט חדש:** כשהוא מאותו סוג — השוואה לאורקל, קלט בתקרות של הפרסר, או סקריפט מדידה. טסט איטי מסוג אחר אינו שייך לכאן: המסלול הזה אינו מקום לכל מה שאיטי.
+- **אין קשר ל-``heavy``.** ``heavy`` שייך לטסטי הביצועים (``-m performance``), ראו :doc:`performance-tests`.
+- **מסלול שלא נבחר בו אף טסט נכשל ואינו עובר בשקט:** pytest יוצא בקוד 5 כשלא נאסף אף טסט, גם כשכולם סוננו ב-``-m`` (נמדד ב-pytest 8.4.2). לכן שם סימון ששונה ב-``ci.yml`` בלי הטסטים, או בכל הטסטים בלי ``ci.yml``, מפיל את המסלול ``md-heavy``. טסט בודד שהסימון שלו חסר או שגוי אינו נתפס כך: הוא עובר למסלול הרגיל ורץ שם, לאט יותר. ``tests/test_required_checks_are_listed.py`` מקבע את קוד היציאה, ובודק שהביטויים של שני המסלולים משלימים זה את זה, כך שכל טסט נבחר במסלול אחד בדיוק.
 
 בדיקות דפדפן, ותקרת הזמן
 -------------------------
diff --git a/docs/whats-new.rst b/docs/whats-new.rst
index 5a8bcfe5f..dc1a85478 100644
--- a/docs/whats-new.rst
+++ b/docs/whats-new.rst
@@ -4,6 +4,7 @@ What's New
 
 2026-10-04
 ----------
+- **ci: טסטי ה-Markdown הכבדים רצים במסלול נפרד, במקביל לשאר טסטי היחידה.** בחודש שעבר זמן הטסטים ב-CI עלה מכשלוש דקות וחצי לכשבע וחצי (שלב ה-pytest בג'וב של 3.12, לפי דוחות ``unit-durations-*`` של ריצות ``ci.yml`` מ-9.9 ומ-4.10). הטסטים שהיו קיימים לא הואטו בסך הכול; את התוספת הביאו טסטים חדשים, ואת החלק הגדול שלה מעט טסטים כבדים. ביניהם טסטי פרסר ה-Markdown שעיקר העבודה שלהם הוא החישוב עצמו: השוואה לאורקל cmark-gfm, קלט ענק בתקרות של הפרסר, והטסטים של סקריפטי המדידה. הם מסומנים עכשיו ``md_heavy`` (הרישום ב-``pytest.ini``), והג'וב ``unit-tests`` ב-``.github/workflows/ci.yml`` רץ בשני מסלולים לכל גרסת פייתון: ``Unit Tests`` מריץ את כל השאר, ו-``Unit Tests md-heavy`` מריץ רק אותם, במקביל ובלי MongoDB ו-Redis שהוא אינו צריך. כל מסלול מדווח סטטוס חובה משלו. **את שני הסטטוסים החדשים צריך לסמן כבדיקות חובה בהגדרות של GitHub**, ועד שזה נעשה כשל בהם מופיע ב-PR אך אינו חוסם מיזוג. ושמות הסטטוסים, שכתובים ביד בכמה קבצים, נבדקים עכשיו מול המטריצה ב-``tests/test_required_checks_are_listed.py`` — והוא נכשל גם כשעותק של הרשימה מופיע בקובץ שהוא לא מכיר. :doc:`testing` ו-:doc:`branch-protection-and-pr-rules` מפנים עכשיו לרשימה שב-:doc:`ci-cd` במקום להחזיק עותק משלהם.
 - **fix (שירות ה-MCP): ריפו שהוסר בממשק נמחק גם מהדיסק של שירות ה-MCP.** הסרת ריפו בוובאפ מחקה את המראה שבדיסק של הוובאפ ואת הרשומות ב-``repo_metadata``, אבל לדיסק של שירות ה-MCP אף אחד לא נגע: המראה שם נשארה, וכלי הקריאה המשיכו להגיש אותה כאילו כלום לא קרה (כך קרה ל-``codekeeper-plugin``). עכשיו בסוף כל מעבר של ה-autosync, כל מראה בדיסק של השירות שאין לה רשומה ב-``repo_metadata`` נמחקת, דרך ``delete_mirror``. שום דבר לא נמחק כשהשאילתה נכשלה, או כשאף שם ב-``repo_metadata`` אינו שם של מראה שבדיסק (כולל קריאה ריקה). כשיש בדיסק מראות שנחסכו כך, נרשמת אזהרה. וגם לא נמחקים תיקייה שאינה מראה שהשירות יוצר (שם לא תקין, קישור סמלי) או ריפו שנמצא באמצע clone או fetch. מחיקה שנכשלה, או תיקיית מראות שאי אפשר לקרוא, נספרות ב-``errors``, והמראה נשארת עד המעבר הבא. הקריאה של ``repo_metadata`` נעשית מה-primary במפורש. בשורת הלוג ``repo autosync pass:`` נוסף המונה ``pruned``. ובאותה מנייה של המראות, גם ניקוי ה-credentials בעלייה מדווח עכשיו על תיקיית מראות שאי אפשר לקרוא ככשל, ולא כ-``checked=0 failed=0``. ראו :ref:`mcp-repo-autosync`.
 - **fix (מראות): טוקן ה-GitHub לא נשמר יותר בקובץ ה-config של המראות, ולא עובר בשורת הפקודה (#3480); וזיהוי הענף הראשי בייבוא ריפו (#3479).** עד עכשיו ``init_mirror`` שכפל מ-URL שהטוקן בתוכו, ו-git שמר אותו בטקסט גלוי ב-``remote.origin.url`` — על הדיסקים של הוובאפ ושל שירות ה-MCP, ובצילומים היומיים של Render; הוא גם הופיע בשורת הפקודה של ``git-remote-http`` בכל clone ו-fetch. עכשיו ה-URL השמור נקי, והטוקן עובר ככותרת דרך משתני סביבה של git, ורק לריפו שדורש הזדהות — ריפו ציבורי לא מקבל טוקן. מראות קיימות מנוקות לפני כל fetch ובעליית כל שירות, עם שורת לוג אחת שסופרת מה נמצא ומה נוקה, ואומרת לכל מראה מאיפה הטוקן שלה (``map``/``global``). fetch על מראה שלא אומת שהיא נקייה לא רץ (``mirror_url_not_clean``). ובנפרד: ``initial_import`` ניסה לזהות את הענף הראשי בפקודות ש-``_run_git_command`` דוחה, ולכן תמיד נפל ל-``main`` — וריפו שהענף הראשי שלו ``master`` לא יובא. עכשיו הזיהוי הוא מ-HEAD של המראה, וכשאין ענף מאומת מוחזר ``default_branch_undetected`` במקום ניחוש. ראו :ref:`mcp-mirror-credentials`.
 - **לפריסה של התיקון הזה:** הניקוי מוציא את הטוקן מהדיסק, אבל צילומי הדיסק של Render שנלקחו לפניו נשמרים לפחות שבעה ימים ועדיין מחזיקים אותו — החלפת הטוקן היא ההחלטה שסוגרת גם אותם. ו-rollback לקוד שלפני התיקון אינו מחזיר את הטוקן למראות שכבר נוקו, ולכן ה-fetch שלהן לריפו פרטי ייכשל באימות; מראה כזו מתקנים במחיקה ושכפול מחדש.
diff --git a/pytest.ini b/pytest.ini
index ca5b986e2..d0651b3d2 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -17,6 +17,7 @@ markers =
     ui_full: סט בדיקות UI מלא שרץ nightly/לפני deploy
     flaky: בדיקות לא יציבות (לא חוסמות CI עד שמייצבים)
     integration: בדיקות אינטגרציה הדורשות שירותים חיצוניים (למשל MongoDB)
+    md_heavy: טסטי Markdown כבדים (אורקל cmark-gfm, קלט בתקרות הפרסר, סקריפטי המדידה) — רצים במסלול md-heavy של unit-tests ב-.github/workflows/ci.yml; ראו docs/testing.rst
 
 # Global per-test timeout to prevent silent hangs in CI
 timeout = 60
diff --git a/tests/test_md_parser.py b/tests/test_md_parser.py
index 227685b0b..3be15b869 100644
--- a/tests/test_md_parser.py
+++ b/tests/test_md_parser.py
@@ -652,6 +652,9 @@ def test_the_new_defaults_are_the_documented_constants():
     assert params["max_tokens"].default is md_parser.MAX_TOKENS
 
 
+# שני הטסטים הבאים מפרסרים קלט שעובר את שתי התקרות, ולכן הם במסלול ``md-heavy`` של
+# ``unit-tests`` ב-``.github/workflows/ci.yml``. שאר הקובץ נשאר במסלול הרגיל.
+@pytest.mark.md_heavy
 def test_the_two_ceilings_can_be_turned_off_explicitly():
     """``None`` מכבה כל אחת מהן — על קלט שעובר את שתי ברירות המחדל."""
     text = "- a\n" * 10_000
@@ -666,6 +669,7 @@ def test_the_two_ceilings_can_be_turned_off_explicitly():
     assert len(doc.lines) == 10_001
 
 
+@pytest.mark.md_heavy
 def test_the_measuring_entries_count_past_the_ceilings():
     """``token_count`` ו-``front_matter_end`` רצים בלי תקרות, בכוונה.
 
diff --git a/tests/test_md_parser_oracle.py b/tests/test_md_parser_oracle.py
index 65307aa2e..c6ad869ed 100644
--- a/tests/test_md_parser_oracle.py
+++ b/tests/test_md_parser_oracle.py
@@ -67,6 +67,11 @@
 
 from services.md_parser import parse_document
 
+#: הקובץ כולו במסלול ``md-heavy`` של ``unit-tests`` ב-``.github/workflows/ci.yml``: הוא
+#: מפרסר את משפחות הצורות של האורקל בשני הפארסרים, כולל טבלאות בתקרת ההשלמה של
+#: ``markdown-it-py``. הסימון מוגדר ב-``pytest.ini``.
+pytestmark = pytest.mark.md_heavy
+
 _REPO = Path(__file__).resolve().parents[1]
 
 #: מכלים שכותרת בתוכם אינה סעיף במסמך. ``blockquote`` ו-``li`` הם מה
diff --git a/tests/test_md_parser_upgrade_zero_diff_script.py b/tests/test_md_parser_upgrade_zero_diff_script.py
index 8a86e52e2..100bed75d 100644
--- a/tests/test_md_parser_upgrade_zero_diff_script.py
+++ b/tests/test_md_parser_upgrade_zero_diff_script.py
@@ -20,6 +20,11 @@
 
 pytest.importorskip("cmarkgfm")
 
+#: הקובץ כולו במסלול ``md-heavy`` של ``unit-tests`` ב-``.github/workflows/ci.yml``: הסקריפט
+#: שהוא בודק מצלם את פלט הפארסרים על קורפוס, על קלטים מעל התקרות ועל משפחות האורקל.
+#: הסימון מוגדר ב-``pytest.ini``.
+pytestmark = pytest.mark.md_heavy
+
 _REPO = Path(__file__).resolve().parent.parent
 
 #: משפחה אחת מ-``_COMPARED_FAMILIES`` ומשפחה אחת של שורה ב-``_KNOWN_DIVERGENCES`` —
diff --git a/tests/test_measure_md_parse_cost_script.py b/tests/test_measure_md_parse_cost_script.py
index b93ab5536..e25adec6f 100644
--- a/tests/test_measure_md_parse_cost_script.py
+++ b/tests/test_measure_md_parse_cost_script.py
@@ -20,6 +20,11 @@
 
 pytest.importorskip("markdown_it")
 
+#: הקובץ כולו במסלול ``md-heavy`` של ``unit-tests`` ב-``.github/workflows/ci.yml``: הסקריפט
+#: שהוא בודק מודד את שיא הזיכרון ואת זמן המעבד של פרסור, כולל הקלט היקר ביותר בתקרות.
+#: הסימון מוגדר ב-``pytest.ini``.
+pytestmark = pytest.mark.md_heavy
+
 _REPO = Path(__file__).resolve().parent.parent
 
 
diff --git a/tests/test_required_checks_are_listed.py b/tests/test_required_checks_are_listed.py
new file mode 100644
index 000000000..0edea2eeb
--- /dev/null
+++ b/tests/test_required_checks_are_listed.py
@@ -0,0 +1,299 @@
+"""שמות הסטטוסים של ``unit-tests`` כתובים בכל רשימה של בדיקות החובה — ורק הם.
+
+הבעלים הוא ``.github/workflows/ci.yml``: כל מסלול של הג'וב ``unit-tests`` מדווח סטטוס
+חובה, ושמו נבנה מהמטריצה (``STATUS_CONTEXT`` בצעדי "Report required status"). אותם
+שמות כתובים ביד ברשימות שאנשים וסוכנים קוראים לפני מיזוג, ורשימה שלא עודכנה אומרת
+ש-PR מוכן בזמן שמסלול שלם עוד לא דיווח. לכן הטסט גוזר את השמות מהמטריצה עצמה — גם
+את התבנית שלהם — ובודק כל רשימה בשני הכיוונים: שכל שם מופיע בה, ושאין בה שם של
+``Unit Tests`` שהמטריצה כבר לא מייצרת.
+
+עמוד שרק צריך להזכיר את הרשימה מפנה ל-``docs/ci-cd.rst`` במקום להחזיק עותק, ולכן
+אינו כאן. קובץ שכן מחזיק עותק בלי להיות ב-``LISTS`` נתפס ב-
+``test_every_file_that_names_a_unit_tests_status_is_checked``, שמחפש שמות של סטטוסים
+בכל הקבצים שבמעקב של git — כי גם ``LISTS`` נכתבת ביד, ועותק שנשכח ממנה לא היה נבדק.
+
+ובנוסף, שני דברים שהמסלולים עצמם נשענים עליהם:
+
+- **הביטויים של המסלולים משלימים זה את זה** (``marker`` במטריצה). טסט שאף מסלול לא
+  בוחר אינו רץ ב-CI בכלל, ואיש לא מקבל על כך הודעה.
+- **מסלול שלא נבחר בו אף טסט נכשל.** זה מה שתופס שם סימון ששונה ב-``ci.yml`` בלי
+  הטסטים, או בכל הטסטים בלי ``ci.yml``: המסלול הכבד היה בוחר אפס טסטים. pytest יוצא אז
+  בקוד ``ExitCode.NO_TESTS_COLLECTED``, וה-CI נשען על זה, ולכן זה מקובע כאן ולא רק כתוב.
+  טסט בודד שהסימון שלו חסר או שגוי אינו נתפס כך, וגם לא צריך: הוא רץ במסלול הרגיל.
+"""
+
+from __future__ import annotations
+
+import itertools
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+import yaml
+
+ROOT = Path(__file__).resolve().parent.parent
+CI_WORKFLOW = ROOT / ".github" / "workflows" / "ci.yml"
+
+#: כל קובץ שמחזיק רשימה של בדיקות החובה, יחסית לשורש הריפו.
+LISTS = (
+    Path("docs") / "ci-cd.rst",
+    Path(".github") / "pull_request_template.md",
+    Path(".github") / "CONTRIBUTING.md",
+    Path(".github") / "agents" / "my-agent.agent.md",
+    Path(".cursorrules"),
+)
+
+#: קבצים שמזכירים שמות של סטטוסים בלי להיות רשימה שפועלים לפיה, ולכן אינם נבדקים מול
+#: המטריצה. לכל קובץ הסיבה שלו.
+SNAPSHOTS = {
+    Path("FEATURE_SUGGESTIONS") / "DOCUMENTATION_NEEDS.md": (
+        "מסמך הצעות לתוכן של אתר התיעוד: הרשימות בו הן הטקסט שהוצע בזמנו, לא מקור שפועלים לפיו"
+    ),
+}
+
+#: ביטוי של GitHub Actions שקורא ערך מהמטריצה, כמו ``${{ matrix.label }}``.
+_MATRIX_EXPRESSION = re.compile(r"\$\{\{\s*matrix\.([\w-]+)\s*\}\}")
+
+#: שם סטטוס של ``Unit Tests`` עם גרסת פייתון אחת. הצורה המסכמת ``Unit Tests (3.11/3.12)``
+#: אינה שם של סטטוס, ולכן אינה נתפסת כאן.
+_UNIT_STATUS = re.compile(r"Unit Tests(?: [\w-]+)? \(\d+\.\d+\)")
+
+#: השורה בסקריפט של צעד דיווח ששולחת את ``STATUS_CONTEXT`` כשם הסטטוס.
+_SENDS_STATUS_CONTEXT = re.compile(r"\bcontext:\s*process\.env\.STATUS_CONTEXT\b")
+
+#: ביטוי ``-m`` שהוא שם של סימון אחד, בלי ``not``, ``and`` או סוגריים.
+_BARE_MARKER = re.compile(r"\w+")
+
+
+def _unit_tests_job() -> dict:
+    workflow = yaml.safe_load(CI_WORKFLOW.read_text(encoding="utf-8"))
+    return workflow["jobs"]["unit-tests"]
+
+
+def _status_template(job: dict) -> str:
+    """התבנית של שם הסטטוס, כפי שכתובה ב-``STATUS_CONTEXT`` של צעדי הדיווח.
+
+    כל צעדי הדיווח חייבים להשתמש באותה תבנית, ובתבנית של ``name`` של הג'וב: אחרת
+    מסלול אחד היה מדווח בשם שהרשימות אינן מכירות. וכל צעד חייב גם לשלוח אותה:
+    ``STATUS_CONTEXT`` ב-env שהסקריפט לא קורא הוא קישוט, וסקריפט שבונה את השם בעצמו מגרסת
+    הפייתון בלבד (כמו שהיה כאן לפני המסלולים) היה כותב מכל המסלולים של אותה גרסה על אותו
+    סטטוס. צעד שחסר לו אחד מהשניים נכשל בהודעה שאומרת מה חסר בו, ולא ב-``KeyError``.
+    """
+    steps = [
+        step for step in job["steps"] if str(step.get("name", "")).startswith("Report required status")
+    ]
+    assert steps, "לא נמצאו צעדי 'Report required status' ב-unit-tests"
+    templates = set()
+    for step in steps:
+        env = step.get("env") or {}
+        assert "STATUS_CONTEXT" in env, f"לצעד {step['name']!r} אין STATUS_CONTEXT ב-env"
+        script = str((step.get("with") or {}).get("script", ""))
+        assert _SENDS_STATUS_CONTEXT.search(script), (
+            f"הצעד {step['name']!r} אינו שולח את STATUS_CONTEXT כשם הסטטוס "
+            "(context: process.env.STATUS_CONTEXT)"
+        )
+        templates.add(env["STATUS_CONTEXT"])
+    assert len(templates) == 1, f"צעדי הדיווח בונים את שם הסטטוס בתבניות שונות: {sorted(templates)}"
+    template = templates.pop()
+    assert template == job["name"], (
+        f"שם הסטטוס ({template!r}) ושם הג'וב ({job['name']!r}) אמורים להיבנות באותה תבנית"
+    )
+    return template
+
+
+def _matrix_combinations(job: dict) -> list[dict]:
+    """כל צירוף של המטריצה, עם המפתחות ש-``include`` מוסיף לו.
+
+    ב-``include`` כל רשומה נקשרת למסלול אחד לפי ``suite`` ומוסיפה לו מפתחות. זה
+    המקרה היחיד שהטסט יודע לפרוש, ולכן הוא מוודא שזה המבנה ולא מנחש.
+    """
+    matrix = job["strategy"]["matrix"]
+    versions = matrix["python-version"]
+    suites = matrix["suite"]
+    by_suite = {}
+    for entry in matrix["include"]:
+        assert entry.get("suite") in suites, f"רשומת include בלי suite מוכר: {entry!r}"
+        assert "python-version" not in entry, f"רשומת include שמשנה גרסה: {entry!r}"
+        assert entry["suite"] not in by_suite, f"שתי רשומות include לאותו suite: {entry!r}"
+        by_suite[entry["suite"]] = entry
+    assert set(by_suite) == set(suites), (
+        f"לכל suite צריכה להיות רשומת include: יש {sorted(by_suite)}, צריך {sorted(suites)}"
+    )
+    return [
+        {**by_suite[suite], "python-version": version, "suite": suite}
+        for version, suite in itertools.product(versions, suites)
+    ]
+
+
+def _expected_statuses() -> set[str]:
+    job = _unit_tests_job()
+    template = _status_template(job)
+    names = set()
+    for combination in _matrix_combinations(job):
+        name = _MATRIX_EXPRESSION.sub(lambda match: combination[match.group(1)], template)
+        assert "${{" not in name, f"נשאר ביטוי שהטסט אינו יודע לפרוש: {name!r}"
+        names.add(name)
+    return names
+
+
+def _lane_markers() -> dict[str, str]:
+    """ביטוי ה-``-m`` של כל מסלול (``matrix.marker``), לפי ``suite``."""
+    markers = {}
+    for combination in _matrix_combinations(_unit_tests_job()):
+        assert "marker" in combination, f"למסלול {combination['suite']!r} אין marker במטריצה"
+        markers[combination["suite"]] = combination["marker"]
+    return markers
+
+
+def _bare_lane_markers(markers: dict[str, str]) -> list[str]:
+    """הביטויים שהם סימון אחד בלבד — כלומר מסלול שבוחר טסטים לפי סימון, ולא לפי היעדרו."""
+    return sorted({marker for marker in markers.values() if _BARE_MARKER.fullmatch(marker)})
+
+
+def _tracked_files_naming_a_unit_tests_status() -> set[Path]:
+    """כל קובץ במעקב של git שמופיע בו שם של סטטוס ``Unit Tests``.
+
+    ``git grep`` על הקידומת שמשותפת לכל השמות רק בוחר מועמדים, וההכרעה היא של
+    ``_UNIT_STATUS`` — כך שהצורה של שם סטטוס מוגדרת במקום אחד, ולא פעם בפייתון ופעם
+    בתחביר של git. הדגלים, לפי ``Documentation/git-grep.txt`` ב-git 2.43: ``-l`` שמות
+    הקבצים בלבד, ``-z`` כל שם מסתיים ב-``\\0`` ומודפס כמו שהוא, ``-I`` בלי קבצים בינאריים,
+    ``-F`` מחרוזת ולא ביטוי. קוד היציאה הוא ``!hit`` (``builtin/grep.c``), כלומר 1 הוא
+    "אף קובץ". כל קוד אחר — למשל 128 מחוץ לעבודה של git — הוא כשל ולא תשובה. וכש-git
+    לא מותקן בכלל, ``subprocess`` מעלה ``FileNotFoundError`` עם שם התוכנה (``_execute_child``
+    ב-``Lib/subprocess.py`` של CPython 3.12). בשני המקרים הטסט נכשל ולא מדלג, בהודעה
+    שאומרת מה חסר: בלי git הוא לא בדק כלום.
+    """
+    try:
+        proc = subprocess.run(
+            ["git", "grep", "-z", "-l", "-I", "-F", "Unit Tests"],
+            cwd=ROOT,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+    except FileNotFoundError as exc:
+        raise AssertionError(
+            f"git לא נמצא ({exc}). הטסט מוצא את העותקים של הרשימה דרך git grep, ובלעדיו לא בדק כלום"
+        ) from exc
+    assert proc.returncode in (0, 1), f"git grep נכשל (קוד {proc.returncode}): {proc.stderr.strip()}"
+    found = set()
+    for name in proc.stdout.split("\0"):
+        # errors="replace": מחפשים שם שכולו ASCII, ובית שאינו UTF-8 במקום אחר בקובץ לא
+        # משנה את ההתאמה.
+        if name and _UNIT_STATUS.search((ROOT / name).read_text(encoding="utf-8", errors="replace")):
+            found.add(Path(name))
+    return found
+
+
+def test_the_status_names_come_from_the_matrix_of_unit_tests():
+    """הבסיס לטסטים שאחריו: כל מסלול מקבל שם משלו, ו-``_UNIT_STATUS`` מזהה כל שם."""
+    job = _unit_tests_job()
+    names = _expected_statuses()
+    assert len(names) == len(_matrix_combinations(job)), f"שני מסלולים מדווחים באותו שם: {sorted(names)}"
+    assert all(_UNIT_STATUS.fullmatch(name) for name in names), (
+        f"שם סטטוס שהביטוי של הטסט אינו מזהה, ולכן לא היה נבדק ברשימות: {sorted(names)}"
+    )
+
+
+def test_every_list_of_required_checks_names_every_unit_tests_status():
+    """רשימה שחסר בה מסלול אומרת ש-PR מוכן בזמן שהמסלול הזה לא נבדק."""
+    expected = _expected_statuses()
+    missing = []
+    for relative in LISTS:
+        text = (ROOT / relative).read_text(encoding="utf-8")
+        missing.extend(f"{relative.as_posix()}: {name}" for name in sorted(expected) if name not in text)
+    assert not missing, "חסרים ברשימות של בדיקות החובה:\n" + "\n".join(missing)
+
+
+def test_no_list_of_required_checks_names_a_unit_tests_status_that_ci_does_not_report():
+    """שם שהמטריצה כבר לא מייצרת הוא בדיקה שלעולם לא תדווח — ו-PR שמחכה לה לא יתמזג."""
+    expected = _expected_statuses()
+    stale = []
+    for relative in LISTS:
+        text = (ROOT / relative).read_text(encoding="utf-8")
+        stale.extend(
+            f"{relative.as_posix()}: {match.group(0)}"
+            for match in _UNIT_STATUS.finditer(text)
+            if match.group(0) not in expected
+        )
+    assert not stale, "שמות שה-CI אינו מדווח:\n" + "\n".join(stale)
+
+
+def test_every_file_that_names_a_unit_tests_status_is_checked():
+    """עותק של הרשימה בקובץ שאינו ב-``LISTS`` היה מתיישן בלי שאיש ידע.
+
+    כך בדיוק קרה כשהמסלול ``md-heavy`` נוסף: הקבצים של ``LISTS`` נאספו בחיפוש ידני,
+    וחלק מהעותקים לא עלו בו. לכן הטסט מחפש בעצמו, בכל הקבצים שבמעקב. קובץ שנמצא צריך
+    אחד משלושה: להיכנס ל-``LISTS`` ולהיבדק, להפנות ל-``docs/ci-cd.rst`` במקום להחזיק
+    עותק, או — כשהוא תמונת מצב ולא רשימה שפועלים לפיה — להיכנס ל-``SNAPSHOTS`` עם
+    הסיבה. ובכיוון ההפוך: פטור לקובץ שכבר לא מזכיר אף סטטוס הוא פטור מת.
+    """
+    found = _tracked_files_naming_a_unit_tests_status()
+    unchecked = sorted(path.as_posix() for path in found - set(LISTS) - set(SNAPSHOTS))
+    assert not unchecked, (
+        "קבצים שמזכירים סטטוס של Unit Tests ואינם נבדקים מול המטריצה. הוסיפו אותם ל-LISTS, "
+        "החליפו את העותק בהפניה ל-docs/ci-cd.rst, או — אם זו תמונת מצב — הוסיפו אותם "
+        "ל-SNAPSHOTS עם הסיבה:\n" + "\n".join(unchecked)
+    )
+    dead = sorted(path.as_posix() for path in set(SNAPSHOTS) - found)
+    assert not dead, "פטורים לקבצים שכבר לא מזכירים אף סטטוס — הסירו אותם מ-SNAPSHOTS:\n" + "\n".join(dead)
+
+
+def test_the_lanes_split_the_suite_into_two_complementary_halves():
+    """טסט שאף מסלול לא בוחר אינו רץ ב-CI בכלל, ואיש לא מקבל על כך הודעה.
+
+    לכן נדרשת הצורה היחידה שהטסט יודע לבדוק: שני מסלולים, אחד בוחר סימון אחד והשני בוחר
+    בדיוק ``not`` אותו סימון. כך כל טסט נבחר במסלול אחד בדיוק. מי שמשנה את הצורה — מסלול
+    שלישי, ביטוי מורכב — מעדכן כאן את בדיקת החלוקה, ולא רק את ``ci.yml``.
+    """
+    markers = _lane_markers()
+    bare = _bare_lane_markers(markers)
+    assert len(markers) == 2 and len(bare) == 1 and set(markers.values()) == {bare[0], f"not {bare[0]}"}, (
+        "הביטויים של המסלולים אינם שני חצאים משלימים (X ו-not X), ולכן טסט יכול להישאר בלי "
+        f"מסלול ולא לרוץ ב-CI בכלל: {markers}"
+    )
+
+
+#: ``1 deselected`` בסיכום של ריצה בלי ``-n`` מראה שהטסט נאסף ואז סונן, ולכן קוד היציאה
+#: בא מהסינון ולא מקובץ שאין בו טסטים. תחת ``-n`` ה-controller מסכם ``no tests ran`` בלי
+#: לספור את מה שסונן ב-workers (נמדד ב-pytest-xdist 3.8.0), ושם אותו קובץ ואותו ביטוי
+#: מספיקים: הריצה בלי ``-n`` כבר הראתה שיש בו טסט שנאסף.
+_SERIAL_SUMMARY = "1 deselected"
+
+
+@pytest.mark.parametrize(
+    ("workers", "summary"), [([], _SERIAL_SUMMARY), (["-n", "2"], None)], ids=["serial", "xdist"]
+)
+def test_a_lane_whose_marker_selects_no_test_fails(tmp_path, workers, summary):
+    """pytest יוצא ב-``ExitCode.NO_TESTS_COLLECTED`` כש-``-m`` סינן את כל הטסטים, וגם תחת ``-n``.
+
+    על זה נשען ה-CI כשהמסלול הכבד בוחר אפס טסטים. נמדד ב-pytest 8.4.2: ``_main`` ב-
+    ``_pytest/main.py`` מחזיר את הקוד הזה כש-``testscollected`` הוא 0, והוא נקבע אחרי הסינון
+    (ותחת ``-n`` ב-``xdist/dsession.py``, ממה שה-workers אספו). הסימון נלקח מהמטריצה, כך שזה
+    הביטוי שהמסלול באמת מריץ. הריצה הפנימית היא ב-``tmp_path`` עם ``pytest.ini`` משלה, ולכן
+    ה-``conftest`` וה-``addopts`` של הריפו אינם נטענים בה.
+    """
+    if workers:
+        pytest.importorskip("xdist")
+    bare = _bare_lane_markers(_lane_markers())
+    assert len(bare) == 1, f"אין למסלול הכבד סימון אחד שבוחרים בו לבד: {bare}"
+    marker = bare[0]
+    (tmp_path / "pytest.ini").write_text(f"[pytest]\nmarkers =\n    {marker}: inner\n", encoding="utf-8")
+    (tmp_path / "test_inner.py").write_text("def test_unmarked():\n    pass\n", encoding="utf-8")
+
+    finished = subprocess.run(
+        [sys.executable, "-B", "-m", "pytest", "-q", "-p", "no:cacheprovider", *workers, "-m", marker, "test_inner.py"],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    output = finished.stdout + finished.stderr
+
+    assert finished.returncode == pytest.ExitCode.NO_TESTS_COLLECTED, (
+        f"מסלול שלא נבחר בו אף טסט יצא בקוד {finished.returncode}, ולכן היה עובר ריק:\n{output}"
+    )
+    if summary is not None:
+        assert summary in output, f"הטסט הפנימי לא נאסף ואז סונן, ולכן הקוד לא הוכיח כלום:\n{output}"