diff --git a/.github/workflows/badges.yml b/.github/workflows/badges.yml
deleted file mode 100644
index 453946e..0000000
--- a/.github/workflows/badges.yml
+++ /dev/null
@@ -1,82 +0,0 @@
-name: Generate Badges
-
-on:
-  workflow_run:
-    workflows: ["Enhanced CI/CD Pipeline"]
-    types:
-      - completed
-  push:
-    branches: [main]
-  workflow_dispatch:
-
-jobs:
-  badges:
-    name: Generate Status Badges
-    runs-on: ubuntu-latest
-    if: ${{ github.event.workflow_run.conclusion == 'success' || github.event_name == 'workflow_dispatch' }}
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          ref: main
-          
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-          
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install coverage pytest pytest-cov
-          pip install -e .
-          
-      - name: Run coverage
-        run: |
-          pytest tests/ --cov=varidex --cov-report=json --cov-report=term
-          
-      - name: Extract coverage percentage
-        id: coverage
-        run: |
-          COVERAGE=$(python -c "import json; print(json.load(open('coverage.json'))['totals']['percent_covered'])")
-          echo "coverage=$COVERAGE" >> $GITHUB_OUTPUT
-          echo "Coverage: $COVERAGE%"
-          
-      - name: Create coverage badge
-        uses: schneegans/dynamic-badges-action@v1.7.0
-        with:
-          auth: ${{ secrets.GIST_SECRET }}
-          gistID: YOUR_GIST_ID_HERE
-          filename: varidex-coverage.json
-          label: Coverage
-          message: ${{ steps.coverage.outputs.coverage }}%
-          color: ${{ steps.coverage.outputs.coverage > 90 && 'brightgreen' || steps.coverage.outputs.coverage > 80 && 'green' || steps.coverage.outputs.coverage > 70 && 'yellow' || 'orange' }}
-        continue-on-error: true
-          
-      - name: Count tests
-        id: tests
-        run: |
-          TEST_COUNT=$(pytest tests/ --collect-only -q | tail -1 | awk '{print $1}')
-          echo "count=$TEST_COUNT" >> $GITHUB_OUTPUT
-          echo "Total tests: $TEST_COUNT"
-          
-      - name: Generate badge data
-        run: |
-          cat > badge-data.json << EOF
-          {
-            "schemaVersion": 1,
-            "label": "tests",
-            "message": "${{ steps.tests.outputs.count }} passing",
-            "color": "brightgreen"
-          }
-          EOF
-          
-      - name: Create badge summary
-        run: |
-          echo "## 🏆 Badge Status" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "- **Coverage**: ${{ steps.coverage.outputs.coverage }}%" >> $GITHUB_STEP_SUMMARY
-          echo "- **Tests**: ${{ steps.tests.outputs.count }} passing" >> $GITHUB_STEP_SUMMARY
-          echo "- **Python**: 3.10, 3.11, 3.12" >> $GITHUB_STEP_SUMMARY
-          echo "- **Status**: Development" >> $GITHUB_STEP_SUMMARY
diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml
deleted file mode 100644
index 86eebc2..0000000
--- a/.github/workflows/cd.yml
+++ /dev/null
@@ -1,34 +0,0 @@
-name: CD  # Deploy VariDex on main
-
-on:
-  push:
-    branches: [main]
-    tags: ['v*']  # Auto-release on tags
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
-      with: python-version: '3.12'
-    - run: pip install build twine pytest-cov
-    - run: python -m build
-    - uses: pypa/gh-action-pypi-publish@release/v1
-      with:
-        password: ${{ secrets.PYPI_TOKEN }}  # Add in Settings > Secrets
-    # Optional Docker for genome tool
-    - uses: docker/login-action@v3
-      with:
-        username: ${{ github.actor }}
-        password: ${{ secrets.GITHUB_TOKEN }}
-    - run: docker build -t ghcr.io/${{ github.repository }}:latest .
-      uses: docker/build-push-action@v6
-      with:
-        push: true
-        tags: ghcr.io/${{ github.repository }}:latest
-  deploy-staging:
-    needs: deploy
-    if: github.ref == 'refs/heads/main'
-    environment: staging  # Settings > Environments > Add
-    # Deploy steps
diff --git a/.github/workflows/ci-enhanced.yml b/.github/workflows/ci-enhanced.yml
deleted file mode 100644
index 8b7d6a6..0000000
--- a/.github/workflows/ci-enhanced.yml
+++ /dev/null
@@ -1,334 +0,0 @@
-name: Enhanced CI/CD Pipeline
-
-on:
-  push:
-    branches: [main, develop, feature/*]
-  pull_request:
-    branches: [main, develop]
-  workflow_dispatch:
-
-env:
-  PYTHON_VERSION_DEFAULT: "3.12"
-  MIN_COVERAGE: 90
-
-jobs:
-  # Code Quality Checks - Fast feedback
-  code-quality:
-    name: Code Quality
-    runs-on: ubuntu-latest
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION_DEFAULT }}
-          cache: 'pip'
-          
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install black mypy flake8 pylint isort
-          pip install -r requirements.txt
-          pip install -r requirements-dev.txt
-          
-      - name: Check Black formatting
-        run: |
-          black --check --diff varidex/ tests/
-          echo "✓ All code is Black-formatted (PEP 8 compliant)"
-          
-      - name: Check import sorting
-        run: |
-          isort --check-only --diff varidex/ tests/
-          
-      - name: Run Flake8
-        run: |
-          flake8 varidex/ tests/ --max-line-length=88 --extend-ignore=E203,W503
-          
-      - name: Run mypy type checking
-        continue-on-error: true
-        run: |
-          mypy varidex/ --config-file=mypy.ini | tee mypy-report.txt
-          
-      - name: Upload type checking report
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: mypy-report
-          path: mypy-report.txt
-          retention-days: 30
-
-  # Security Scanning
-  security:
-    name: Security Scan
-    runs-on: ubuntu-latest
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION_DEFAULT }}
-          cache: 'pip'
-          
-      - name: Install security tools
-        run: |
-          python -m pip install --upgrade pip
-          pip install bandit safety detect-secrets
-          
-      - name: Run Bandit security linter
-        continue-on-error: true
-        run: |
-          bandit -r varidex/ -f json -o bandit-report.json
-          bandit -r varidex/ -f txt
-          
-      - name: Check dependencies for vulnerabilities
-        continue-on-error: true
-        run: |
-          safety check --json > safety-report.json || true
-          safety check || true
-          
-      - name: Detect secrets
-        run: |
-          detect-secrets scan --baseline .secrets.baseline
-          
-      - name: Upload security reports
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: security-reports
-          path: |
-            bandit-report.json
-            safety-report.json
-          retention-days: 30
-
-  # Matrix Testing - Multiple Python Versions
-  test:
-    name: Tests (Python ${{ matrix.python-version }})
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest]
-        python-version: ["3.10", "3.11", "3.12"]
-        
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-          cache: 'pip'
-          
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -e .
-          pip install -r requirements-test.txt
-          
-      - name: Run unit tests
-        run: |
-          pytest tests/ \
-            --cov=varidex \
-            --cov-report=xml \
-            --cov-report=term \
-            --cov-report=html \
-            --junitxml=junit-${{ matrix.python-version }}.xml \
-            -v \
-            --tb=short
-          
-      - name: Check coverage threshold
-        run: |
-          coverage report --fail-under=${{ env.MIN_COVERAGE }}
-          
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        with:
-          file: ./coverage.xml
-          flags: python-${{ matrix.python-version }}
-          name: Python-${{ matrix.python-version }}
-          fail_ci_if_error: false
-          
-      - name: Upload test results
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: test-results-${{ matrix.python-version }}
-          path: |
-            junit-${{ matrix.python-version }}.xml
-            htmlcov/
-          retention-days: 30
-          
-      - name: Generate coverage badge
-        if: matrix.python-version == env.PYTHON_VERSION_DEFAULT
-        run: |
-          coverage report | grep TOTAL | awk '{print "Coverage: " $NF}'
-
-  # Integration & E2E Tests
-  integration-tests:
-    name: Integration Tests
-    runs-on: ubuntu-latest
-    needs: [code-quality]
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION_DEFAULT }}
-          cache: 'pip'
-          
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -e .
-          pip install -r requirements-test.txt
-          
-      - name: Run integration tests
-        run: |
-          pytest tests/test_integration_e2e.py -v --tb=short
-          
-      - name: Run pipeline validation tests
-        run: |
-          pytest tests/test_pipeline_validators.py -v --tb=short
-
-  # Build & Package Validation
-  build:
-    name: Build Package
-    runs-on: ubuntu-latest
-    needs: [test]
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION_DEFAULT }}
-          cache: 'pip'
-          
-      - name: Install build tools
-        run: |
-          python -m pip install --upgrade pip
-          pip install build twine check-wheel-contents
-          
-      - name: Build distribution packages
-        run: |
-          python -m build
-          ls -lh dist/
-          
-      - name: Check package metadata
-        run: |
-          twine check dist/*
-          
-      - name: Validate wheel contents
-        run: |
-          check-wheel-contents dist/*.whl
-          
-      - name: Upload build artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: dist-packages
-          path: dist/
-          retention-days: 30
-
-  # Documentation Build Test
-  docs:
-    name: Documentation
-    runs-on: ubuntu-latest
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION_DEFAULT }}
-          cache: 'pip'
-          
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements-docs.txt
-          
-      - name: Check docs for broken links
-        continue-on-error: true
-        run: |
-          if [ -d "docs/" ]; then
-            echo "Documentation directory found"
-            # Add sphinx-build or mkdocs commands here when ready
-          else
-            echo "No docs directory yet - skipping"
-          fi
-          
-      - name: Validate README
-        run: |
-          python -c "import re; content=open('README.md').read(); assert len(content)>1000, 'README too short'"
-          echo "✓ README.md is comprehensive"
-
-  # Performance Benchmarking (Optional)
-  performance:
-    name: Performance Benchmarks
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request'
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION_DEFAULT }}
-          cache: 'pip'
-          
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -e .
-          pip install pytest-benchmark
-          
-      - name: Run performance benchmarks
-        continue-on-error: true
-        run: |
-          echo "Performance benchmarking placeholder"
-          echo "Add pytest-benchmark tests when ready"
-
-  # Final Status Check
-  ci-success:
-    name: CI Pipeline Success
-    runs-on: ubuntu-latest
-    needs: [code-quality, security, test, integration-tests, build, docs]
-    if: always()
-    
-    steps:
-      - name: Check all jobs status
-        run: |
-          echo "Code Quality: ${{ needs.code-quality.result }}"
-          echo "Security: ${{ needs.security.result }}"
-          echo "Tests: ${{ needs.test.result }}"
-          echo "Integration: ${{ needs.integration-tests.result }}"
-          echo "Build: ${{ needs.build.result }}"
-          echo "Docs: ${{ needs.docs.result }}"
-          
-          if [ "${{ needs.code-quality.result }}" != "success" ] || \
-             [ "${{ needs.test.result }}" != "success" ] || \
-             [ "${{ needs.integration-tests.result }}" != "success" ] || \
-             [ "${{ needs.build.result }}" != "success" ]; then
-            echo "❌ CI Pipeline Failed"
-            exit 1
-          fi
-          
-          echo "✅ CI Pipeline Passed - All checks successful"
-          echo "📦 Build artifacts ready for deployment"
-          echo "⚠️  Status: DEVELOPMENT (Not for production use)"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e69de29..0feead2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,59 @@
+# VariDex CI — the gate. This workflow is `./check.sh`, and nothing else.
+#
+# WHAT THIS REPLACES. Nine workflows that enforced nothing: `ci.yml` was 0 bytes, every pytest and
+# coverage step carried `continue-on-error: true` ("non-blocking during development"), and Codecov
+# ran with `fail_ci_if_error: false`. Worse, none of it ever ran: the install step did
+# `pip install -e .` against a pyproject.toml with NO [project] table, then
+# `pip install -r requirements-test.txt` against a file that was never committed. Both fail, the
+# install step had no continue-on-error, and so every test step after it was UNREACHABLE. Every
+# `test.yml` run in the repository's history is a failure; the most recent was 2026-02-09.
+#
+# THE RULE THIS ENCODES: a check must distinguish EXAMINED-AND-CLEAN from NEVER-EXAMINED. Each gate
+# in check.sh returns 2 when it could not examine anything, and check.sh reports that as REFUSED —
+# never as a pass. An install failure now reads INSTALL FAILED, not as a test result.
+name: CI
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+  workflow_dispatch:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    name: check.sh (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.10', '3.11', '3.12']
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      # NO continue-on-error anywhere in this file, deliberately. If install fails the job fails
+      # here, loudly, and the log says INSTALL FAILED — it does not silently skip the gates and
+      # report a green tick, which is precisely how this repo went six months without a test run.
+      - name: Install
+        run: |
+          set -euo pipefail
+          python -m pip install --upgrade pip setuptools wheel
+          pip install -e . || { echo "::error::INSTALL FAILED — package metadata is broken. No tests were run."; exit 1; }
+          pip install -r requirements-test.txt || { echo "::error::INSTALL FAILED — test requirements unresolvable. No tests were run."; exit 1; }
+          pip install ruff mypy
+
+      # check.sh IS the CI. Run it locally and you have run this job.
+      - name: check.sh
+        env:
+          PY: python
+        run: ./check.sh
diff --git a/.github/workflows/dependabot.yml b/.github/workflows/dependabot.yml
deleted file mode 100644
index e35ec9d..0000000
--- a/.github/workflows/dependabot.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "pip"
-    directory: "/"
-    schedule: {interval: "weekly"}
diff --git a/.github/workflows/dependency-updates.yml b/.github/workflows/dependency-updates.yml
deleted file mode 100644
index 55b3bdf..0000000
--- a/.github/workflows/dependency-updates.yml
+++ /dev/null
@@ -1,140 +0,0 @@
-name: Dependency Updates
-
-on:
-  schedule:
-    # Run every Monday at 09:00 UTC
-    - cron: '0 9 * * 1'
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  # ==================== CHECK OUTDATED PACKAGES ====================
-  check-outdated:
-    name: Check Outdated Packages
-    runs-on: ubuntu-latest
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-    
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install pip-check pip-audit
-        pip install -r requirements.txt
-        pip install -r requirements-test.txt
-    
-    - name: Check for outdated packages
-      run: |
-        echo "📊 Checking for outdated packages..."
-        pip list --outdated > outdated-packages.txt
-        cat outdated-packages.txt
-    
-    - name: Upload outdated packages report
-      uses: actions/upload-artifact@v4
-      with:
-        name: outdated-packages-report
-        path: outdated-packages.txt
-        retention-days: 30
-
-  # ==================== SECURITY UPDATES ====================
-  security-updates:
-    name: Check Security Updates
-    runs-on: ubuntu-latest
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-    
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install safety pip-audit
-        pip install -r requirements.txt
-        pip install -r requirements-test.txt
-    
-    - name: Run Safety check
-      run: |
-        echo "🔒 Checking for known vulnerabilities..."
-        pip freeze | safety check --stdin --json > safety-report.json || true
-        pip freeze | safety check --stdin || true
-    
-    - name: Run pip-audit
-      run: |
-        echo "🔍 Auditing packages for vulnerabilities..."
-        pip-audit --desc --format json > pip-audit-report.json || true
-        pip-audit --desc || true
-    
-    - name: Upload security reports
-      uses: actions/upload-artifact@v4
-      with:
-        name: security-update-reports
-        path: |
-          safety-report.json
-          pip-audit-report.json
-        retention-days: 90
-
-  # ==================== PYTHON VERSION COMPATIBILITY ====================
-  python-compat:
-    name: Test Python ${{ matrix.python-version }} Compatibility
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ['3.9', '3.10', '3.11', '3.12']
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-    
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ matrix.python-version }}
-    
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -e .
-    
-    - name: Test import
-      run: |
-        python -c "import varidex; print(f'VariDex v{varidex.__version__} works on Python ${{ matrix.python-version }}')"
-    
-    - name: Run basic tests
-      run: |
-        pip install pytest
-        pytest tests/ -v --maxfail=3 || echo "⚠️ Some tests failed on Python ${{ matrix.python-version }}"
-
-  # ==================== DEPENDENCY SUMMARY ====================
-  summary:
-    name: Dependency Update Summary
-    runs-on: ubuntu-latest
-    needs: [check-outdated, security-updates, python-compat]
-    if: always()
-    
-    steps:
-    - name: Generate summary
-      run: |
-        echo "📊 ===================================="
-        echo "📊 DEPENDENCY UPDATE CHECK COMPLETE"
-        echo "📊 ===================================="
-        echo "📊 Results:"
-        echo "  - Outdated Check: ${{ needs.check-outdated.result }}"
-        echo "  - Security Updates: ${{ needs.security-updates.result }}"
-        echo "  - Python Compatibility: ${{ needs.python-compat.result }}"
-        echo "📊 ===================================="
-        echo "ℹ️ Check artifacts for detailed reports"
-        echo "📊 ===================================="
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
deleted file mode 100644
index 01cd5b8..0000000
--- a/.github/workflows/test.yml
+++ /dev/null
@@ -1,122 +0,0 @@
-name: CI/CD Tests
-
-on:
-  push:
-    branches: [ main, develop ]
-  pull_request:
-    branches: [ main ]
-  workflow_dispatch:
-
-jobs:
-  test:
-    name: Test Python ${{ matrix.python-version }} on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ['3.10', '3.11', '3.12']
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-    
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ matrix.python-version }}
-        cache: 'pip'
-    
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip setuptools wheel
-        pip install -e .
-        pip install -r requirements-test.txt
-    
-    - name: Run tests with pytest (non-blocking during development)
-      run: |
-        pytest tests/ -v --tb=short --strict-markers
-      continue-on-error: true
-    
-    - name: Run tests with coverage
-      if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11'
-      run: |
-        pytest tests/ --cov=varidex --cov-report=xml --cov-report=term
-      continue-on-error: true
-    
-    - name: Upload coverage to Codecov
-      if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11'
-      uses: codecov/codecov-action@v4
-      with:
-        file: ./coverage.xml
-        flags: unittests
-        name: codecov-umbrella
-        fail_ci_if_error: false
-      continue-on-error: true
-
-  lint:
-    name: Code Quality Checks
-    runs-on: ubuntu-latest
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-    
-    - name: Set up Python 3.11
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-        cache: 'pip'
-    
-    - name: Install linting tools
-      run: |
-        python -m pip install --upgrade pip
-        pip install flake8 black mypy
-    
-    - name: Check code formatting with Black
-      run: |
-        black --check --diff varidex/ tests/
-    
-    - name: Lint with flake8 (non-blocking during development)
-      run: |
-        flake8 varidex/ tests/ --count --select=E9,F63,F7,F82 --show-source --statistics
-        flake8 varidex/ tests/ --count --max-line-length=100 --statistics
-      continue-on-error: true
-    
-    - name: Type check with mypy (non-blocking)
-      run: |
-        mypy varidex/ --ignore-missing-imports
-      continue-on-error: true
-
-  build:
-    name: Build Package
-    runs-on: ubuntu-latest
-    needs: [test, lint]
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-    
-    - name: Set up Python 3.11
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    
-    - name: Install build tools
-      run: |
-        python -m pip install --upgrade pip build twine
-    
-    - name: Build package
-      run: |
-        python -m build
-    
-    - name: Check package with twine
-      run: |
-        twine check dist/*
-    
-    - name: Upload build artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: dist-packages
-        path: dist/
-        retention-days: 7
diff --git a/.gitignore b/.gitignore
index 51b2f28..f04d420 100644
--- a/.gitignore
+++ b/.gitignore
@@ -55,3 +55,10 @@ temp_phase1.py
 cleanup_*.py
 downloader.py
 test_*.py
+.venv/
+
+# test run artifacts
+/output
+/report.html
+.coverage
+coverage.xml
diff --git a/check.sh b/check.sh
new file mode 100755
index 0000000..e636fb7
--- /dev/null
+++ b/check.sh
@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+# check.sh — this IS the CI, runnable locally. If this passes, CI passes.
+#
+# VariDex had nine workflows and enforced nothing: ci.yml was 0 bytes, every pytest step carried
+# continue-on-error, and the install step referenced a requirements-test.txt that was never
+# committed — so the job died at install and no test ever ran. Every test.yml run in the history is
+# a failure; the last was 2026-02-09. A green badge meant nothing had been examined.
+#
+# So every gate below distinguishes EXAMINED-AND-CLEAN from NEVER-EXAMINED, and each returns a
+# distinct exit code for "refused" so a dead tool can never read as a pass.
+#
+# Usage:  ./check.sh            all gates
+#         ./check.sh --quick    skip coverage (the slow one)
+set -uo pipefail
+cd "$(dirname "$0")"
+PY="${PY:-python}"
+[ -x .venv/bin/python ] && PY=.venv/bin/python
+QUICK=0; [ "${1:-}" = "--quick" ] && QUICK=1
+FAILED=(); REFUSED=()
+run() { # run <label> <cmd...>
+  local label="$1"; shift
+  printf '\n=== %s ===\n' "$label"
+  "$@"; local rc=$?
+  case $rc in
+    0) printf '  ok\n' ;;
+    2) printf '  REFUSED (nothing was examined)\n'; REFUSED+=("$label") ;;
+    *) printf '  FAILED (rc=%d)\n' "$rc"; FAILED+=("$label") ;;
+  esac
+}
+
+# 1 · SYNTAX — every tracked .py must parse. A file that cannot be parsed is invisible to ruff,
+#     mypy and pytest alike, so this runs FIRST and blocks any NEW unparseable file.
+syntax_gate() {
+  local known=scripts/known-broken-syntax.txt broken=() f
+  while IFS= read -r f; do
+    [ -n "$f" ] || continue
+    "$PY" -m py_compile "$f" 2>/dev/null || broken+=("$f")
+  done < <(git ls-files '*.py')
+  local unexpected=()
+  for f in "${broken[@]}"; do
+    grep -qxF "$f" "$known" 2>/dev/null || unexpected+=("$f")
+  done
+  local fixed=()
+  while IFS= read -r f; do
+    case "$f" in ''|'#'*) continue ;; esac
+    printf '%s\n' "${broken[@]}" | grep -qxF "$f" || fixed+=("$f")
+  done < "$known"
+  if [ ${#unexpected[@]} -gt 0 ]; then
+    printf 'NEW unparseable file(s):\n'; printf '  + %s\n' "${unexpected[@]}"; return 1
+  fi
+  if [ ${#fixed[@]} -gt 0 ]; then
+    printf 'These now PARSE — delete them from %s:\n' "$known"; printf '  - %s\n' "${fixed[@]}"; return 1
+  fi
+  printf '  %d tracked .py files parse (%d known-broken, unchanged)\n' \
+    "$(git ls-files '*.py' | wc -l)" "${#broken[@]}"
+}
+
+coverage_gate() {
+  local floor; floor=$(grep -vE '^\s*#|^\s*$' scripts/coverage-floor.txt | head -1)
+  local out; out=$("$PY" -m pytest tests/ --tb=no -q -p no:cacheprovider \
+      --cov=varidex --cov=src --cov-report=term 2>&1)
+  local pct; pct=$(printf '%s' "$out" | sed 's/\x1b\[[0-9;]*m//g' | grep -E '^TOTAL' | awk '{print $NF}' | tr -d '%')
+  if [ -z "$pct" ]; then
+    printf 'REFUSE: no TOTAL line — coverage was never measured. Not a pass.\n'
+    printf '%s\n' "$out" | tail -20; return 2
+  fi
+  printf '  coverage %s%% (floor %s%%)\n' "$pct" "$floor"
+  [ "$pct" -ge "$floor" ] || { printf 'FAIL: coverage %s%% is below the floor %s%%.\n' "$pct" "$floor"; return 1; }
+  [ "$pct" -gt "$floor" ] && printf '  IMPROVED — raise the floor in scripts/coverage-floor.txt.\n'
+  return 0
+}
+
+run "syntax (all tracked .py parse)"     syntax_gate
+run "ruff lint ratchet"                  "$PY" scripts/check_ruff_ratchet.py
+# Exclusions live in pyproject.toml [tool.ruff] so the CLI and the config cannot drift apart.
+run "ruff format"                        "$PY" -m ruff format --check varidex/ src/ tests/
+run "mypy advisory ratchet"              "$PY" scripts/check_mypy_ratchet.py
+run "pytest two-direction ratchet"       "$PY" scripts/check_test_ratchet.py
+[ $QUICK -eq 0 ] && run "coverage floor"  coverage_gate
+
+printf '\n========================================\n'
+if [ ${#REFUSED[@]} -gt 0 ]; then
+  printf 'REFUSED (%d) — a gate could not examine anything:\n' "${#REFUSED[@]}"
+  printf '  %s\n' "${REFUSED[@]}"
+  printf 'This is NOT a pass. Fix the tooling before reading any other result.\n'
+fi
+if [ ${#FAILED[@]} -gt 0 ]; then
+  printf 'FAILED (%d):\n' "${#FAILED[@]}"; printf '  %s\n' "${FAILED[@]}"
+fi
+if [ ${#FAILED[@]} -eq 0 ] && [ ${#REFUSED[@]} -eq 0 ]; then
+  printf 'ALL GATES PASS\n'; exit 0
+fi
+exit 1
diff --git a/mypy.ini b/mypy.ini
index 1e8da8f..5b2f075 100644
--- a/mypy.ini
+++ b/mypy.ini
@@ -2,7 +2,6 @@
 # Development-friendly type checking
 
 [mypy]
-python_version = 3.9
 warn_return_any = False
 warn_unused_configs = True
 disallow_untyped_defs = False
diff --git a/pyproject.toml b/pyproject.toml
index 3eef6cc..75ce334 100755
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,3 +1,53 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "varidex"
+version = "6.0.0"
+description = "VariDex — genomic variant annotation and classification pipeline"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "AGPL-3.0-or-later" }
+
+# DERIVED, NOT GUESSED. This is the set under which `import varidex` succeeds in a clean
+# virtualenv — established empirically (2026-08-28), not read off the import list. Modules
+# importing pysam/pyyaml/lxml/pyliftover are reachable only through submodules and are declared
+# as extras below; the GPU stack (cudf, cuml, rmm, torch) is optional by construction and is not
+# declared at all, because nothing here can verify it.
+dependencies = [
+    "numpy",
+    "pandas",
+    "requests",
+    "tqdm",
+    "psutil",
+]
+
+[project.optional-dependencies]
+vcf = ["pysam"]
+config = ["pyyaml"]
+
+[tool.ruff]
+# Ruff replaces black + isort + flake8 here.
+#
+# Markdown is excluded deliberately: `ruff format` rewrites Python snippets inside prose, and a
+# formatter reflowing a documentation example is not a code-quality signal. Scoping to real source
+# keeps the gate about code.
+extend-exclude = [
+    "*.md",
+    # Not valid Python — its function body was commented out, leaving a def with no block. Nothing
+    # imports it. Excluded so ruff can check the other 124 files AT ALL; check.sh's syntax gate
+    # reports it separately and blocks any NEW unparseable file, so this does not hide it.
+    "varidex/pipeline/phase1_enhancement.py",
+]
+
+[tool.setuptools.packages.find]
+# Both trees are importable today and the test suite imports from each. Declaring them here is
+# what makes `pip install -e .` reproduce what `PYTHONPATH=.` provided, so CI stops depending on
+# an environment variable nobody set.
+where = ["."]
+include = ["varidex*", "src*"]
+
 [tool.mypy]
 ignore_missing_imports = true
 disallow_untyped_defs = false
diff --git a/requirements-test.txt b/requirements-test.txt
new file mode 100644
index 0000000..a0a40a6
--- /dev/null
+++ b/requirements-test.txt
@@ -0,0 +1,29 @@
+# VariDex test dependencies.
+#
+# DERIVED, NOT GUESSED (2026-08-28). Each entry below is here because pytest collection or a test
+# actually failed without it — the set was established by running the suite in a clean virtualenv
+# and adding only what the failures named. `tqdm`, `psutil` and `click` were discovered exactly this
+# way: five test files failed to import until they were present, and nothing in the repo declared
+# them. `pysam` and `pyyaml` each accounted for further failures that were dependency-driven rather
+# than logic-driven.
+#
+# The file this replaces did not exist. CI referenced `requirements-test.txt` for months while no
+# such file was ever committed, so the install step failed and every test step after it was
+# unreachable. If you add a test that needs a new package, add it here in the same commit.
+
+# runtime deps the package itself needs (mirrors [project].dependencies)
+numpy
+pandas
+requests
+tqdm
+psutil
+
+# reachable only via submodules, but exercised by the suite
+pysam
+pyyaml
+
+# test framework and helpers
+pytest>=7.0
+pytest-cov
+hypothesis
+click
diff --git a/scripts/check_mypy_ratchet.py b/scripts/check_mypy_ratchet.py
new file mode 100644
index 0000000..6d6b233
--- /dev/null
+++ b/scripts/check_mypy_ratchet.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""Advisory mypy ratchet for VariDex — the count may fall, never rise.
+
+    fewer errors than the baseline  -> PASS, and tells you to lower the baseline
+    more errors than the baseline   -> FAIL
+    neither summary line present    -> REFUSE (exit 2)
+
+The third case is the whole point. `mypy` prints "Found N errors" on failure and
+"Success: no issues found" on success -- but when it dies early (a syntax error in a scanned file,
+an unreadable config, a crash) it prints NEITHER, and a checker that greps only for "Found N errors"
+reads that silence as clean. VariDex was in exactly that state: mypy.ini pinned python_version to
+3.9, which current mypy rejects outright, and a syntax error in a shipped module stopped checking
+after one file. Nothing reported it for months.
+
+So absence of a summary is a REFUSAL, distinct from both pass and fail.
+
+Usage:
+    python scripts/check_mypy_ratchet.py            # check against the baseline
+    python scripts/check_mypy_ratchet.py --selftest
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+BASELINE = ROOT / "scripts" / "mypy-baseline.txt"
+
+EXIT_OK, EXIT_FAIL, EXIT_REFUSE = 0, 1, 2
+
+_ANSI = re.compile(r"\x1b\[[0-9;]*m|\(B")
+_FOUND = re.compile(r"Found (\d+) errors? in \d+ files?")
+_CLEAN = re.compile(r"Success: no issues found")
+
+# The orphaned module below is genuinely broken Python (its body was commented out, leaving a
+# def with no block) and nothing imports it. It is EXCLUDED so mypy can check the other 110
+# files at all -- not to hide it. `check.sh`'s syntax gate reports it separately and blocks any
+# NEW broken file, so excluding it here does not make it invisible.
+EXCLUDES = ["phase1_enhancement\\.py", ".*Copy.*"]
+
+
+def parse_count(output: str) -> int | None:
+    """Error count, or None if mypy produced no summary at all (-> refuse)."""
+    clean = _ANSI.sub("", output)
+    m = _FOUND.search(clean)
+    if m:
+        return int(m.group(1))
+    if _CLEAN.search(clean):
+        return 0
+    return None
+
+
+def load_baseline() -> int | None:
+    if not BASELINE.exists():
+        return None
+    for line in BASELINE.read_text().splitlines():
+        line = line.strip()
+        if line and not line.startswith("#"):
+            try:
+                return int(line)
+            except ValueError:
+                continue
+    return None
+
+
+def run_mypy() -> str:
+    cmd = [sys.executable, "-m", "mypy", "varidex/"]
+    for e in EXCLUDES:
+        cmd += ["--exclude", e]
+    proc = subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True)
+    return proc.stdout + proc.stderr
+
+
+def selftest() -> int:
+    fails: list[str] = []
+
+    def ok(c: bool, m: str) -> None:
+        if not c:
+            fails.append(m)
+
+    ok(parse_count("Found 41 errors in 16 files (checked 110 source files)") == 41, "parses a count")
+    ok(parse_count("Success: no issues found in 110 source files") == 0, "parses a clean run")
+    ok(parse_count("Found 1 error in 1 file (errors prevented further checking)") == 1, "singular 'error' parses")
+
+    # THE REFUSALS -- each of these is what a dying mypy actually looks like.
+    ok(parse_count("") is None, "empty output REFUSES, not clean")
+    ok(
+        parse_count("mypy.ini: [mypy]: python_version: Python 3.9 is not supported") is None,
+        "a config rejection REFUSES",
+    )
+    ok(
+        parse_count("varidex/x.py:85: error: Expected an indented block  [syntax]") is None,
+        "errors with no summary line REFUSE -- this is the dead-as-clean case",
+    )
+    ok(parse_count("Traceback (most recent call last):") is None, "a crash REFUSES")
+
+    print(f"SELFTEST FAIL ({len(fails)})\n  " + "\n  ".join(fails) if fails else "SELFTEST PASS (7/7)")
+    return EXIT_FAIL if fails else EXIT_OK
+
+
+def main() -> int:
+    if "--selftest" in sys.argv:
+        return selftest()
+
+    baseline = load_baseline()
+    if baseline is None:
+        print(f"REFUSE: no baseline at {BASELINE}", file=sys.stderr)
+        return EXIT_REFUSE
+
+    output = run_mypy()
+    count = parse_count(output)
+
+    if count is None:
+        print("=" * 72, file=sys.stderr)
+        print("REFUSE: mypy produced no summary line.", file=sys.stderr)
+        print("It printed neither 'Found N errors' nor 'Success'. That means it DIED --", file=sys.stderr)
+        print("a syntax error, an unreadable config, or a crash. Nothing was checked.", file=sys.stderr)
+        print("This is NOT clean. Read the output below.", file=sys.stderr)
+        print("=" * 72, file=sys.stderr)
+        print(output[-3000:], file=sys.stderr)
+        return EXIT_REFUSE
+
+    print(f"mypy: {count} error(s) - baseline {baseline}")
+
+    if count > baseline:
+        print(f"\nFAIL: type errors rose {baseline} -> {count}.", file=sys.stderr)
+        print("Fix them, or the change does not land.", file=sys.stderr)
+        print(_ANSI.sub("", output)[-3000:], file=sys.stderr)
+        return EXIT_FAIL
+
+    if count < baseline:
+        print(f"\nIMPROVED: {baseline} -> {count}. Lower the number in {BASELINE.name} in this commit,")
+        print("so the gain is locked in and cannot be given back silently.")
+
+    return EXIT_OK
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/check_ruff_ratchet.py b/scripts/check_ruff_ratchet.py
new file mode 100644
index 0000000..c68bf88
--- /dev/null
+++ b/scripts/check_ruff_ratchet.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Ruff lint ratchet — the count may fall, never rise. Same shape as the mypy ratchet.
+
+Ruff replaces black + isort + flake8 here. The existing 1318 findings are NOT auto-fixed in the
+commit that introduces this gate: doing so would bury a CI change under a whole-repo reformat and
+make the diff unreviewable. They are recorded instead, and the count can only go down.
+
+    fewer than baseline -> PASS (lower the baseline in the same commit)
+    more than baseline  -> FAIL
+    no count line       -> REFUSE (exit 2) -- ruff died; that is not "clean"
+
+Usage:
+    python scripts/check_ruff_ratchet.py [--selftest]
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+BASELINE = ROOT / "scripts" / "ruff-baseline.txt"
+# Exclusions are declared once, in pyproject.toml [tool.ruff], so this tool and the config
+# cannot drift apart. See there for why the one unparseable file is skipped.
+TARGETS = ["varidex/", "src/", "tests/"]
+EXIT_OK, EXIT_FAIL, EXIT_REFUSE = 0, 1, 2
+
+_ANSI = re.compile(r"\x1b\[[0-9;]*m")
+_FOUND = re.compile(r"Found (\d+) errors?")
+_CLEAN = re.compile(r"All checks passed")
+
+
+def parse_count(output: str) -> int | None:
+    clean = _ANSI.sub("", output)
+    m = _FOUND.search(clean)
+    if m:
+        return int(m.group(1))
+    if _CLEAN.search(clean):
+        return 0
+    return None
+
+
+def load_baseline() -> int | None:
+    if not BASELINE.exists():
+        return None
+    for line in BASELINE.read_text().splitlines():
+        s = line.strip()
+        if s and not s.startswith("#"):
+            try:
+                return int(s)
+            except ValueError:
+                continue
+    return None
+
+
+def selftest() -> int:
+    fails: list[str] = []
+
+    def ok(c: bool, m: str) -> None:
+        if not c:
+            fails.append(m)
+
+    ok(parse_count("Found 1318 errors.") == 1318, "parses a count")
+    ok(parse_count("All checks passed!") == 0, "parses a clean run")
+    ok(parse_count("Found 1 error.") == 1, "singular parses")
+    ok(parse_count("") is None, "empty output REFUSES, not clean")
+    ok(parse_count("error: Failed to parse pyproject.toml") is None, "a ruff crash REFUSES")
+    print(f"SELFTEST FAIL ({len(fails)})\n  " + "\n  ".join(fails) if fails else "SELFTEST PASS (5/5)")
+    return EXIT_FAIL if fails else EXIT_OK
+
+
+def main() -> int:
+    if "--selftest" in sys.argv:
+        return selftest()
+    baseline = load_baseline()
+    if baseline is None:
+        print(f"REFUSE: no baseline at {BASELINE}", file=sys.stderr)
+        return EXIT_REFUSE
+    proc = subprocess.run(
+        [sys.executable, "-m", "ruff", "check", *TARGETS], cwd=ROOT, capture_output=True, text=True
+    )
+    out = proc.stdout + proc.stderr
+    count = parse_count(out)
+    if count is None:
+        print("REFUSE: ruff produced no count line -- it died. Not clean.", file=sys.stderr)
+        print(out[-2000:], file=sys.stderr)
+        return EXIT_REFUSE
+    print(f"ruff: {count} finding(s) - baseline {baseline}")
+    if count > baseline:
+        print(f"\nFAIL: lint findings rose {baseline} -> {count}.", file=sys.stderr)
+        print(_ANSI.sub("", out)[-2500:], file=sys.stderr)
+        return EXIT_FAIL
+    if count < baseline:
+        print(f"IMPROVED: {baseline} -> {count}. Lower {BASELINE.name} in this commit.")
+    return EXIT_OK
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/check_test_ratchet.py b/scripts/check_test_ratchet.py
new file mode 100644
index 0000000..db684d9
--- /dev/null
+++ b/scripts/check_test_ratchet.py
@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Two-direction test ratchet for VariDex.
+
+Runs the suite, compares the failing set against the committed baseline in
+``tests/known-failures.txt``, and enforces that the baseline can only SHRINK.
+
+    a failure NOT in the baseline         -> FAIL (exit 1).  New breakage cannot enter.
+    a baseline entry that now PASSES      -> FAIL (exit 1).  Delist it; the baseline must not rot.
+    the suite did not actually run        -> REFUSE (exit 2). NOT the same as "clean".
+
+The third case is the one that makes this trustworthy. VariDex's CI failed for six months in a way
+that looked like nothing: the install step died, every pytest step after it was skipped, and no
+check ever said so. A gate that cannot tell "examined and clean" from "never examined" would have
+reported that state as success. So an unparseable run, a collection error, or a zero-test run is a
+REFUSAL with a distinct exit code -- never a pass, and never a plain failure either.
+
+Usage:
+    python scripts/check_test_ratchet.py            # run the suite and check
+    python scripts/check_test_ratchet.py --selftest # verify the checker itself
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+BASELINE = ROOT / "tests" / "known-failures.txt"
+
+EXIT_OK, EXIT_FAIL, EXIT_REFUSE = 0, 1, 2
+
+_ANSI = re.compile(r"\x1b\[[0-9;]*m")
+_SUMMARY = re.compile(r"^=+ .*?(\d+) failed.*?(\d+) passed", re.M)
+_COLLECTED = re.compile(r"^collected (\d+) items", re.M)
+
+
+def load_baseline(path: Path = BASELINE) -> set[str]:
+    if not path.exists():
+        return set()
+    out = set()
+    for line in path.read_text().splitlines():
+        line = line.strip()
+        if line and not line.startswith("#"):
+            out.add(line)
+    return out
+
+
+def parse_failures(output: str) -> set[str]:
+    """Failing node IDs from pytest short-summary output."""
+    clean = _ANSI.sub("", output)
+    return {
+        m.group(1)
+        for m in re.finditer(r"^FAILED (\S+?)(?:\s|$)", clean, re.M)
+    }
+
+
+def parse_passed_count(output: str) -> int | None:
+    clean = _ANSI.sub("", output)
+    m = re.search(r"(\d+) passed", clean)
+    return int(m.group(1)) if m else None
+
+
+def ran_at_all(output: str) -> tuple[bool, str]:
+    """Did the suite actually execute? Returns (ran, reason-if-not).
+
+    Deliberately strict: absence of evidence that tests ran is treated as 'did not run', because
+    the failure mode this guards against produces empty-looking output that a lenient parser
+    reads as clean.
+    """
+    clean = _ANSI.sub("", output)
+    if "error: no such file" in clean.lower() or "ERROR: Could not find" in clean:
+        return False, "dependency install appears to have failed"
+    if "Interrupted" in clean and "errors during collection" in clean:
+        return False, "collection errors interrupted the run -- no tests executed"
+    m = _COLLECTED.search(clean)
+    if m and int(m.group(1)) == 0:
+        return False, "zero tests collected"
+    if parse_passed_count(clean) is None and not parse_failures(clean):
+        return False, "no pass/fail counts in output -- the suite did not report results"
+    return True, ""
+
+
+def compare(current: set[str], baseline: set[str]) -> tuple[set[str], set[str]]:
+    """Returns (new_failures, fixed_but_still_listed)."""
+    return current - baseline, baseline - current
+
+
+def run_suite() -> str:
+    proc = subprocess.run(
+        [sys.executable, "-m", "pytest", "tests/", "--tb=no", "-q", "-p", "no:cacheprovider"],
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+    )
+    return proc.stdout + proc.stderr
+
+
+def selftest() -> int:
+    fails: list[str] = []
+
+    def ok(cond: bool, msg: str) -> None:
+        if not cond:
+            fails.append(msg)
+
+    good = "collected 10 items\nFAILED tests/a.py::test_x - boom\n== 1 failed, 9 passed in 1s =="
+    ok(parse_failures(good) == {"tests/a.py::test_x"}, "parses a failing node id")
+    ok(ran_at_all(good)[0], "a normal run counts as having run")
+
+    # NEW failure -> caught
+    new, fixed = compare({"tests/a.py::test_x", "tests/b.py::test_y"}, {"tests/a.py::test_x"})
+    ok(new == {"tests/b.py::test_y"}, "a new failure is detected")
+    ok(not fixed, "no spurious 'fixed' when nothing was fixed")
+
+    # listed test now PASSING -> caught (the anti-rot direction)
+    new, fixed = compare(set(), {"tests/a.py::test_x"})
+    ok(fixed == {"tests/a.py::test_x"}, "a baseline entry that now passes is detected")
+    ok(not new, "no spurious 'new' when nothing is new")
+
+    # REFUSALS -- each must be distinguishable from clean
+    ok(not ran_at_all("collected 0 items\n")[0], "zero collected is a refusal")
+    ok(not ran_at_all("")[0], "empty output is a refusal, NOT a pass")
+    ok(
+        not ran_at_all("Interrupted: 5 errors during collection")[0],
+        "collection errors are a refusal",
+    )
+    ok(
+        not ran_at_all("ERROR: Could not find a version that satisfies the requirement")[0],
+        "an install failure is a refusal, not a test result",
+    )
+
+    # A clean run with zero failures and a real pass count must NOT refuse.
+    ok(ran_at_all("collected 5 items\n== 5 passed in 1s ==")[0], "an all-green run is not a refusal")
+
+    print(
+        f"SELFTEST FAIL ({len(fails)})\n  " + "\n  ".join(fails)
+        if fails
+        else "SELFTEST PASS (11/11)"
+    )
+    return EXIT_FAIL if fails else EXIT_OK
+
+
+def main() -> int:
+    if "--selftest" in sys.argv:
+        return selftest()
+
+    baseline = load_baseline()
+    if not baseline:
+        print(f"REFUSE: no baseline at {BASELINE}. Record one before gating.", file=sys.stderr)
+        return EXIT_REFUSE
+
+    output = run_suite()
+    ran, why = ran_at_all(output)
+    if not ran:
+        print("=" * 72, file=sys.stderr)
+        print(f"REFUSE: the test suite did not run -- {why}", file=sys.stderr)
+        print("This is NOT a pass and NOT a test failure. Nothing was examined.", file=sys.stderr)
+        print("=" * 72, file=sys.stderr)
+        print(output[-3000:], file=sys.stderr)
+        return EXIT_REFUSE
+
+    current = parse_failures(output)
+    new, fixed = compare(current, baseline)
+
+    print(f"baseline {len(baseline)} known failures - current run {len(current)} failing")
+
+    if not new and not fixed:
+        print("RATCHET OK: the failing set matches the baseline exactly.")
+        return EXIT_OK
+
+    if new:
+        print(f"\nNEW FAILURES ({len(new)}) -- not in the baseline:", file=sys.stderr)
+        for t in sorted(new):
+            print(f"  + {t}", file=sys.stderr)
+        print("\nFix them, or the change that caused them does not land.", file=sys.stderr)
+
+    if fixed:
+        print(f"\nFIXED BUT STILL LISTED ({len(fixed)}):", file=sys.stderr)
+        for t in sorted(fixed):
+            print(f"  - {t}", file=sys.stderr)
+        print(
+            "\nThese now PASS. Delete them from tests/known-failures.txt in this commit --\n"
+            "the baseline must shrink when a test is fixed, or it rots into an excuse list.",
+            file=sys.stderr,
+        )
+
+    return EXIT_FAIL
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/coverage-floor.txt b/scripts/coverage-floor.txt
new file mode 100644
index 0000000..7563fa5
--- /dev/null
+++ b/scripts/coverage-floor.txt
@@ -0,0 +1,9 @@
+# VariDex coverage floor — RATCHET UP ONLY.
+#
+# 26 recorded 2026-08-28 from the first run that could execute at all (10092 statements, 7423
+# missed). It rose to 27% once the import-rot fixes let more tests run; the floor is held at 26 so
+# the gate has one point of headroom against measurement noise across Python versions.
+#
+# This is the MEASURED number, deliberately not an aspirational one. Raise it whenever a run comes
+# in higher — never lower it.
+26
diff --git a/scripts/known-broken-syntax.txt b/scripts/known-broken-syntax.txt
new file mode 100644
index 0000000..f60dcf8
--- /dev/null
+++ b/scripts/known-broken-syntax.txt
@@ -0,0 +1,16 @@
+# Files that are not valid Python. Recorded 2026-08-28.
+#
+# ONE entry. An earlier scan of mine reported two, because the filename
+# "varidex/pipeline/__main__ (Copy).py" contains a SPACE and word-split into two arguments; that
+# file parses fine. Recorded here because the same word-splitting will bite the next person who
+# scans this tree without quoting.
+#
+# varidex/pipeline/phase1_enhancement.py — the body of add_phase1_codes_to_pipeline was commented
+#   out, leaving a def with no block (IndentationError at line 85). It is ORPHANED: orchestrator_v2
+#   defines its own apply_phase1_enhancements and does NOT import this module. Left unfixed
+#   deliberately — the original implementation is gone, and inventing one would be fabrication
+#   rather than repair. It is listed so the syntax gate can BLOCK ANY NEW unparseable file while
+#   this one stands, instead of every tool skipping it silently.
+#
+# To clear the entry: fix or delete the file, then delete this line.
+varidex/pipeline/phase1_enhancement.py
diff --git a/scripts/mypy-baseline.txt b/scripts/mypy-baseline.txt
new file mode 100644
index 0000000..a200e2e
--- /dev/null
+++ b/scripts/mypy-baseline.txt
@@ -0,0 +1,15 @@
+# VariDex mypy error baseline — ADVISORY RATCHET.
+#
+# Recorded 2026-08-28 against tree 88d2394: 41 errors in 16 files, 110 source files checked.
+#
+# The count may FALL, never RISE. When you fix type errors, lower this number in the same commit
+# so the gain is locked in and cannot be given back silently.
+#
+# This is advisory in the sense that the 41 existing errors do not block; it is NOT advisory about
+# regressions — a 42nd error reds the build.
+#
+# Two files are excluded (see scripts/check_mypy_ratchet.py EXCLUDES): an orphaned module whose
+# body was commented out, leaving genuinely invalid Python, and a stray "(Copy)" backup. They are
+# excluded so the other 110 files can be checked AT ALL — not to hide them. check.sh gates them
+# separately and blocks any NEW unparseable file.
+41
diff --git a/scripts/ruff-baseline.txt b/scripts/ruff-baseline.txt
new file mode 100644
index 0000000..79c4987
--- /dev/null
+++ b/scripts/ruff-baseline.txt
@@ -0,0 +1,8 @@
+# VariDex ruff lint baseline — RATCHET. Recorded 2026-08-28 against tree 88d2394.
+#
+# 1316 findings across varidex/ src/ tests/ (874 auto-fixable).
+#
+# They are NOT auto-fixed in the commit that introduces this gate: a whole-repo reformat would bury
+# the CI change and make the diff unreviewable. Fix them in later, focused commits and lower this
+# number each time. It can only go down.
+1316
diff --git a/tests/known-failures.txt b/tests/known-failures.txt
new file mode 100644
index 0000000..3f23aa9
--- /dev/null
+++ b/tests/known-failures.txt
@@ -0,0 +1,93 @@
+# VariDex known test failures — the RATCHET BASELINE.
+#
+# Recorded 2026-08-28 against tree 88d2394.
+# 68 failures, 789 passing, 10 skipped, out of 867 collected.
+#
+# WHY THIS FILE EXISTS. Before it, `test.yml` referenced a `requirements-test.txt` that was never
+# committed and ran `pip install -e .` against a pyproject.toml with no [project] table. Both lines
+# failed, the install step had no continue-on-error, and so every pytest step after it was
+# UNREACHABLE. The `continue-on-error: true` on those steps was irrelevant — they never executed.
+# Every test.yml run in the history is a failure; the most recent was 2026-02-09.
+#
+# So the suite could not be gated on green: it is not green. This file makes it gateable ANYWAY, by
+# recording exactly what fails today and refusing to let that set grow.
+#
+# THE RATCHET RUNS IN TWO DIRECTIONS, and the second one is the point:
+#   * a failure NOT listed here          -> RED. New breakage cannot enter.
+#   * a listed test that starts PASSING  -> RED, until it is deleted from this file.
+# The second direction is what stops the baseline rotting into a permanent excuse list. Without it a
+# file like this only ever grows stale, and a fixed test silently keeps its licence to fail.
+#
+# TO FIX A TEST: fix it, delete its line here, commit both together. That is the only way the
+# number goes down, and it is the only direction it can move.
+#
+# DO NOT regenerate this file wholesale to make CI green. Regenerating is how a real regression gets
+# absorbed into the baseline and disappears. If the checker reds, read what it names.
+tests/test_cli_interface.py::TestCLIArguments::test_cli_help_flag
+tests/test_cli_interface.py::TestCLIArguments::test_cli_required_args
+tests/test_cli_interface.py::TestCLIArguments::test_cli_version_flag
+tests/test_cli_interface.py::TestCLIConfigurationOptions::test_cli_invalid_config_file
+tests/test_cli_interface.py::TestCLIErrorHandling::test_cli_interrupt_handling
+tests/test_cli_interface.py::TestCLIErrorHandling::test_cli_invalid_format_error
+tests/test_cli_interface.py::TestCLIErrorHandling::test_cli_missing_input_error
+tests/test_cli_interface.py::TestCLIErrorHandling::test_cli_permission_error
+tests/test_cli_interface.py::TestCLIExecution::test_cli_verbose_mode
+tests/test_cli_interface.py::TestCLIFileValidation::test_cli_input_file_permissions
+tests/test_cli_interface.py::TestCLIOutputFormats::test_cli_auto_format_detection
+tests/test_cli_interface.py::TestCLIOutputFormats::test_cli_csv_output
+tests/test_cli_interface.py::TestCLIOutputFormats::test_cli_json_output
+tests/test_cli_interface.py::TestCLIOutputFormats::test_cli_vcf_output
+tests/test_cli_interface.py::TestCLIProgressReporting::test_cli_log_file_creation
+tests/test_cli_interface.py::TestCLIProgressReporting::test_cli_log_level
+tests/test_cli_interface.py::TestCLIProgressReporting::test_cli_progress_bar
+tests/test_core_models.py::TestAnnotatedVariant::test_annotated_variant_creation
+tests/test_core_models.py::TestAnnotatedVariant::test_cadd_score_range
+tests/test_core_models.py::TestAnnotatedVariant::test_gnomad_af_range
+tests/test_core_models.py::TestVariantClassification::test_confidence_range
+tests/test_core_models.py::TestVariantCreation::test_full_variant_creation
+tests/test_core_models.py::TestVariantCreation::test_variant_with_optional_fields
+tests/test_core_models.py::TestVariantIdentifier::test_variant_id_generation
+tests/test_core_models.py::TestVariantSerialization::test_round_trip_serialization
+tests/test_core_models.py::TestVariantValidation::test_invalid_chromosome
+tests/test_coverage_boost_integration_paths.py::TestFileReadingEdgeCases::test_very_large_file_size
+tests/test_coverage_boost_validation.py::TestChromosomeValidation::test_chromosome_with_special_characters
+tests/test_coverage_boost_validation.py::TestChromosomeValidation::test_invalid_chromosome_names
+tests/test_coverage_boost_validation.py::TestPositionValidation::test_position_string_rejected
+tests/test_coverage_gaps.py::TestDownloaderCoverage::test_download_with_invalid_url
+tests/test_coverage_gaps.py::TestDownloaderCoverage::test_download_with_timeout
+tests/test_data_validation.py::TestBoundaryConditions::test_extreme_float_values
+tests/test_data_validation.py::TestBoundaryConditions::test_max_chromosome_length
+tests/test_data_validation.py::TestDataFrameValidation::test_duplicate_variants
+tests/test_data_validation.py::TestFrequencyValidation::test_valid_frequencies
+tests/test_data_validation.py::TestVariantDataValidation::test_invalid_positions
+tests/test_downloader.py::TestDownloadFile::test_download_file_http_error
+tests/test_downloader.py::TestDownloadFile::test_download_file_network_error
+tests/test_downloader.py::TestDownloadFile::test_download_file_success
+tests/test_downloader.py::TestDownloadFile::test_download_file_with_progress
+tests/test_downloader.py::TestDownloadRetry::test_download_retry_exhausted
+tests/test_downloader.py::TestDownloadRetry::test_download_retry_success_on_second_attempt
+tests/test_downloader.py::TestResourceDownloader::test_clear_cache
+tests/test_downloader.py::TestResourceDownloader::test_download_resource_already_cached
+tests/test_downloader.py::TestResourceDownloader::test_download_resource_checksum_mismatch
+tests/test_downloader.py::TestResourceDownloader::test_download_resource_force_redownload
+tests/test_downloader.py::TestResourceDownloader::test_download_resource_not_cached
+tests/test_downloader.py::TestResourceDownloader::test_download_resource_with_checksum
+tests/test_downloader.py::TestResourceDownloader::test_get_cache_size
+tests/test_downloader.py::TestResourceDownloader::test_init_custom_cache_dir
+tests/test_downloader.py::TestResourceDownloader::test_init_default_cache_dir
+tests/test_downloader.py::TestResourceDownloader::test_list_cached_files
+tests/test_edge_cases.py::TestDataTypeConversions::test_numeric_to_string_conversion
+tests/test_edge_cases.py::TestDataTypeConversions::test_string_to_numeric_conversion
+tests/test_edge_cases.py::TestMalformedData::test_mixed_type_chromosome
+tests/test_error_recovery.py::TestDataValidationErrors::test_invalid_position_format
+tests/test_error_recovery.py::TestExceptionHierarchy::test_base_exception_inheritance
+tests/test_integration_e2e.py::TestDataIntegrity::test_allele_normalization_integrity
+tests/test_integration_e2e.py::TestDataIntegrity::test_roundtrip_vcf_to_dataframe
+tests/test_integration_e2e.py::TestEndToEndPipeline::test_e2e_multi_source_integration
+tests/test_integration_e2e.py::TestEndToEndPipeline::test_e2e_single_variant_annotation
+tests/test_integration_e2e.py::TestPerformanceIntegration::test_large_vcf_processing
+tests/test_integration_e2e.py::TestPerformanceIntegration::test_memory_efficient_processing
+tests/test_pipeline_validators.py::TestValidateVariant::test_validate_variant_invalid_position
+tests/test_pipeline_validators.py::TestValidateVariant::test_validate_variant_invalid_reference
+tests/test_pipeline_validators.py::TestValidationEdgeCases::test_validate_variant_missing_fields
+tests/test_pipeline_validators.py::TestValidationPerformance::test_validate_mixed_validity
diff --git a/tests/test_integration_e2e.py b/tests/test_integration_e2e.py
index 16bbf31..4e34154 100644
--- a/tests/test_integration_e2e.py
+++ b/tests/test_integration_e2e.py
@@ -29,7 +29,7 @@ def test_e2e_single_variant_annotation(self, tmp_path: Path) -> None:
         vcf_file.write_text(vcf_content)
 
         # Read and validate
-        from varidex.io.loaders.vcf_loader import load_vcf
+        from varidex.io.loaders.vcfloader import load_vcf
         from varidex.pipeline.validators import validate_vcf_file
 
         assert validate_vcf_file(vcf_file)
@@ -81,7 +81,7 @@ def test_e2e_multi_source_integration(self, tmp_path: Path) -> None:
         vcf_file.write_text(vcf_content)
 
         # Load variants
-        from varidex.io.loaders.vcf_loader import load_vcf
+        from varidex.io.loaders.vcfloader import load_vcf
 
         variants_df = load_vcf(vcf_file)
 
@@ -189,7 +189,7 @@ def test_large_vcf_processing(self, tmp_path: Path) -> None:
                 f.write(f"{chrom}\t{pos}\t.\tA\tG\t100\tPASS\t.\n")
 
         # Load and process
-        from varidex.io.loaders.vcf_loader import load_vcf
+        from varidex.io.loaders.vcfloader import load_vcf
 
         variants_df = load_vcf(vcf_file)
         assert len(variants_df) == n_variants
@@ -239,7 +239,7 @@ def test_memory_efficient_processing(self, tmp_path: Path) -> None:
                 f.write(f"{chrom}\t{pos}\t.\tA\tG\t100\tPASS\t.\n")
 
         # Process in chunks (memory-efficient)
-        from varidex.io.loaders.vcf_loader import load_vcf_chunked
+        from varidex.io.loaders.vcfloader import load_vcf_chunked
 
         total_variants = 0
         for chunk in load_vcf_chunked(vcf_gz, chunk_size=10000):
@@ -264,7 +264,7 @@ def test_roundtrip_vcf_to_dataframe(self, tmp_path: Path) -> None:
         original_vcf.write_text(vcf_content)
 
         # Load
-        from varidex.io.loaders.vcf_loader import load_vcf
+        from varidex.io.loaders.vcfloader import load_vcf
         from varidex.io.writers.vcf_writer import write_vcf
 
         variants_df = load_vcf(original_vcf)
@@ -336,14 +336,14 @@ def test_pipeline_handles_malformed_input(self, tmp_path: Path) -> None:
         malformed_vcf = tmp_path / "malformed.vcf"
         malformed_vcf.write_text("This is not a valid VCF file")
 
-        from varidex.io.loaders.vcf_loader import load_vcf
+        from varidex.io.loaders.vcfloader import load_vcf
 
         with pytest.raises((ValidationError, ValueError)):
             load_vcf(malformed_vcf)
 
     def test_pipeline_handles_missing_files(self) -> None:
         """Test pipeline error handling with missing files."""
-        from varidex.io.loaders.vcf_loader import load_vcf
+        from varidex.io.loaders.vcfloader import load_vcf
 
         with pytest.raises(FileNotFoundError):
             load_vcf(Path("/nonexistent/file.vcf"))
diff --git a/varidex/__main__.py b/varidex/__main__.py
index 4d7aeaa..ac307ab 100644
--- a/varidex/__main__.py
+++ b/varidex/__main__.py
@@ -10,6 +10,7 @@
 - Better error handling for missing dbNSFP data
 - Clear logging for PS3 application
 """
+
 import sys
 from argparse import ArgumentParser, Namespace
 from pathlib import Path
@@ -251,7 +252,7 @@ def print_summary(df: pd.DataFrame) -> None:
 
     print(
         f"\n📊 Evidence Coverage: {with_evidence:,}/{len(df):,} "
-        f"({with_evidence/len(df)*100:.1f}%)"
+        f"({with_evidence / len(df) * 100:.1f}%)"
     )
 
     # Priority codes breakdown
@@ -285,7 +286,7 @@ def print_summary(df: pd.DataFrame) -> None:
         if high_risk > 0:
             print(
                 f"\n⚠️  High-Risk Variants (PVS1/PS3 or PM2+PP3): {high_risk:,} "
-                f"({high_risk/len(df)*100:.1f}%)"
+                f"({high_risk / len(df) * 100:.1f}%)"
             )
 
 
diff --git a/varidex/acmg/criteria.py b/varidex/acmg/criteria.py
index 508d87c..673cf84 100644
--- a/varidex/acmg/criteria.py
+++ b/varidex/acmg/criteria.py
@@ -126,7 +126,9 @@ def count_bs(self) -> int:
 
     def count_bp(self) -> int:
         """Count supporting benign evidence."""
-        return sum([self.bp1, self.bp2, self.bp3, self.bp4, self.bp5, self.bp6, self.bp7])
+        return sum(
+            [self.bp1, self.bp2, self.bp3, self.bp4, self.bp5, self.bp6, self.bp7]
+        )
 
     def has_conflicting_evidence(self) -> bool:
         """
@@ -143,9 +145,7 @@ def has_conflicting_evidence(self) -> bool:
             or self.count_pp() > 0
         )
 
-        has_benign = (
-            self.count_ba() > 0 or self.count_bs() > 0 or self.count_bp() > 0
-        )
+        has_benign = self.count_ba() > 0 or self.count_bs() > 0 or self.count_bp() > 0
 
         return has_pathogenic and has_benign
 
@@ -275,21 +275,15 @@ def validate(self) -> List[str]:
 
         # PS4 (prevalence increased) conflicts with BS4 (lack of segregation)
         if self.ps4 and self.bs4:
-            warnings.append(
-                "PS4 conflicts with BS4: case-control data contradiction"
-            )
+            warnings.append("PS4 conflicts with BS4: case-control data contradiction")
 
         # PP2 (missense in gene with low missense) conflicts with BP1
         if self.pp2 and self.bp1:
-            warnings.append(
-                "PP2 conflicts with BP1: missense mechanism contradiction"
-            )
+            warnings.append("PP2 conflicts with BP1: missense mechanism contradiction")
 
         # PS3 (functional studies supportive) conflicts with BS3
         if self.ps3 and self.bs3:
-            warnings.append(
-                "PS3 conflicts with BS3: functional studies contradiction"
-            )
+            warnings.append("PS3 conflicts with BS3: functional studies contradiction")
 
         # PM3 (in trans with pathogenic) conflicts with BP2 (in trans with benign)
         if self.pm3 and self.bp2:
diff --git a/varidex/acmg/criteria_PS3_PP2.py b/varidex/acmg/criteria_PS3_PP2.py
index 0f32cc5..9795ece 100644
--- a/varidex/acmg/criteria_PS3_PP2.py
+++ b/varidex/acmg/criteria_PS3_PP2.py
@@ -122,7 +122,7 @@ def apply_ps3_only(self, df: pd.DataFrame) -> pd.DataFrame:
                 ps3_count += 1
 
         logger.info(
-            f"  ✅ PS3 applied to {ps3_count} variants ({ps3_count/len(df)*100:.1f}%)"
+            f"  ✅ PS3 applied to {ps3_count} variants ({ps3_count / len(df) * 100:.1f}%)"
         )
 
         return df
@@ -161,7 +161,7 @@ def apply_pp2_only(self, df: pd.DataFrame) -> pd.DataFrame:
                     pp2_count += 1
 
         logger.info(
-            f"  ✅ PP2 applied to {pp2_count} variants ({pp2_count/len(df)*100:.1f}%)"
+            f"  ✅ PP2 applied to {pp2_count} variants ({pp2_count / len(df) * 100:.1f}%)"
         )
 
         return df
diff --git a/varidex/acmg/criteria_ba4_bp2.py b/varidex/acmg/criteria_ba4_bp2.py
index 74fe9a4..58a9f2a 100644
--- a/varidex/acmg/criteria_ba4_bp2.py
+++ b/varidex/acmg/criteria_ba4_bp2.py
@@ -52,8 +52,7 @@ def __init__(
             self._load_constraint_data(constraint_path)
         else:
             logger.warning(
-                f"BA4/BP2: Constraint file not found at {constraint_path}, "
-                "BA4 disabled"
+                f"BA4/BP2: Constraint file not found at {constraint_path}, BA4 disabled"
             )
 
     def _load_constraint_data(self, path: str) -> None:
@@ -69,9 +68,7 @@ def _load_constraint_data(self, path: str) -> None:
 
             # FIXED: BA4 applies to LoF-TOLERANT genes (oe_lof_upper > threshold)
             tolerant_mask = self.constraint_df["oe_lof_upper"] > self.ba4_threshold
-            self.tolerant_genes = set(
-                self.constraint_df[tolerant_mask]["gene_symbol"]
-            )
+            self.tolerant_genes = set(self.constraint_df[tolerant_mask]["gene_symbol"])
 
             # Also track constrained genes for logging
             constrained_mask = self.constraint_df["oe_lof_upper"] < 0.1
@@ -123,8 +120,10 @@ def apply_ba4(self, df: pd.DataFrame) -> pd.DataFrame:
         ]
 
         has_gene = df["gene"].notna()
-        is_lof = df["molecular_consequence"].str.lower().isin(
-            [c.lower() for c in lof_consequences]
+        is_lof = (
+            df["molecular_consequence"]
+            .str.lower()
+            .isin([c.lower() for c in lof_consequences])
         )
         in_tolerant_gene = df["gene"].isin(self.tolerant_genes)
 
diff --git a/varidex/acmg/criteria_pm3.py b/varidex/acmg/criteria_pm3.py
index 134e707..d1c1410 100644
--- a/varidex/acmg/criteria_pm3.py
+++ b/varidex/acmg/criteria_pm3.py
@@ -16,6 +16,7 @@
 
 Development version - not for production use.
 """
+
 import logging
 import pandas as pd
 from typing import Optional
@@ -92,10 +93,14 @@ def apply_pm3(
             logger.warning("⚠️  PM3: Disabled - phasing data required but not available")
             return df
 
-        pathogenic_genes = df[
-            df.clinical_sig.str.contains("Pathogenic", na=False)
-            & ~df.clinical_sig.str.contains("Benign", na=False)
-        ].gene.dropna().unique()
+        pathogenic_genes = (
+            df[
+                df.clinical_sig.str.contains("Pathogenic", na=False)
+                & ~df.clinical_sig.str.contains("Benign", na=False)
+            ]
+            .gene.dropna()
+            .unique()
+        )
 
         count = 0
         low_confidence_count = 0
@@ -164,7 +169,7 @@ def apply_pm3(
         if self.enable_distance_heuristic:
             logger.info(
                 f"⭐ PM3: {count} potential compound heterozygotes "
-                f"({pm3_pct:.1f}%) [distance heuristic: >{self.distance_threshold/1e6:.1f}Mb]"
+                f"({pm3_pct:.1f}%) [distance heuristic: >{self.distance_threshold / 1e6:.1f}Mb]"
             )
             if low_confidence_count > 0:
                 logger.warning(
diff --git a/varidex/acmg/criteria_pm5.py b/varidex/acmg/criteria_pm5.py
index 0627fbf..bb4fd65 100644
--- a/varidex/acmg/criteria_pm5.py
+++ b/varidex/acmg/criteria_pm5.py
@@ -16,6 +16,7 @@
 
 Development version - not for production use.
 """
+
 import logging
 import re
 import pandas as pd
@@ -80,9 +81,7 @@ def _extract_protein_position(self, hgvs_p: str) -> Optional[int]:
 
         return None
 
-    def _build_pathogenic_index(
-        self, clinvar_df: pd.DataFrame
-    ) -> Set[Tuple[str, int]]:
+    def _build_pathogenic_index(self, clinvar_df: pd.DataFrame) -> Set[Tuple[str, int]]:
         """
         Extract pathogenic protein positions as hash set.
 
diff --git a/varidex/acmg/dbnsfp_annotator.py b/varidex/acmg/dbnsfp_annotator.py
index 98c4496..3f26daa 100644
--- a/varidex/acmg/dbnsfp_annotator.py
+++ b/varidex/acmg/dbnsfp_annotator.py
@@ -211,7 +211,7 @@ def annotate_with_dbnsfp(
     )
 
     print(
-        f"\n✓ Total annotated: {annotated_count}/{len(df)} ({annotated_count/len(df)*100:.1f}%)\n"
+        f"\n✓ Total annotated: {annotated_count}/{len(df)} ({annotated_count / len(df) * 100:.1f}%)\n"
     )
 
     return df
diff --git a/varidex/acmg/dbnsfp_gpu_annotator.py b/varidex/acmg/dbnsfp_gpu_annotator.py
index 695bb9c..9a67636 100644
--- a/varidex/acmg/dbnsfp_gpu_annotator.py
+++ b/varidex/acmg/dbnsfp_gpu_annotator.py
@@ -19,7 +19,8 @@ class GPUdbNSFPAnnotator:
     def __init__(self, dbnsfp_dir: str):
         self.dbnsfp_dir = dbnsfp_dir
         rmm.reinitialize(
-            allocated_gpu_bytes=8_000_000_000, managed_memory=True  # 8GB GPU memory
+            allocated_gpu_bytes=8_000_000_000,
+            managed_memory=True,  # 8GB GPU memory
         )
 
     def annotate(self, variants_df: pd.DataFrame) -> cudf.DataFrame:
diff --git a/varidex/core/classifier/VERSION_HISTORY.md b/varidex/core/classifier/VERSION_HISTORY.md
index 1afec28..60f40e0 100644
--- a/varidex/core/classifier/VERSION_HISTORY.md
+++ b/varidex/core/classifier/VERSION_HISTORY.md
@@ -134,9 +134,7 @@ result = classifier.classify_variant(variant)
 from varidex.core.classifier import ACMGClassifierV8
 
 classifier = ACMGClassifierV8(
-    gnomad_api_key="your_key",
-    dbnsfp_path="/path/to/dbNSFP",
-    spliceai_enabled=True
+    gnomad_api_key="your_key", dbnsfp_path="/path/to/dbNSFP", spliceai_enabled=True
 )
 result = classifier.classify_variant(variant)
 ```
@@ -179,10 +177,12 @@ result = classifier.classify_variant(variant)
 ```python
 # Before (V7)
 from varidex.core.classifier import ACMGClassifierV7
+
 classifier = ACMGClassifierV7(gnomad_api_key=key)
 
 # After (Base)
 from varidex.core.classifier import ACMGClassifier
+
 classifier = ACMGClassifier()  # No API key needed
 
 # Note: PM2 and BS2 will not be assigned
@@ -193,14 +193,14 @@ classifier = ACMGClassifier()  # No API key needed
 ```python
 # Before (V8)
 from varidex.core.classifier import ACMGClassifierV8
+
 classifier = ACMGClassifierV8(
-    gnomad_api_key=key,
-    dbnsfp_path=path,
-    spliceai_enabled=True
+    gnomad_api_key=key, dbnsfp_path=path, spliceai_enabled=True
 )
 
 # After (Base)
 from varidex.core.classifier import ACMGClassifier
+
 classifier = ACMGClassifier()  # Simplified
 
 # Note: PM2, PP3, BP4, BP7 will not be assigned
@@ -225,7 +225,7 @@ classifier = ACMGClassifier(
     integrations={
         "gnomad": {"api_key": key, "enabled": True},
         "spliceai": {"enabled": True},
-        "dbnsfp": {"path": path, "enabled": True}
+        "dbnsfp": {"path": path, "enabled": True},
     }
 )
 ```
@@ -310,7 +310,9 @@ from varidex.core.classifier import ACMGClassifier
 
 # Available if dependencies installed
 from varidex.core.classifier import ACMGClassifierV7  # Needs gnomad-api
-from varidex.core.classifier import ACMGClassifierV8  # Needs gnomad-api, spliceai, dbnsfp
+from varidex.core.classifier import (
+    ACMGClassifierV8,
+)  # Needs gnomad-api, spliceai, dbnsfp
 ```
 
 ### Testing Status
diff --git a/varidex/core/classifier/__init__.py b/varidex/core/classifier/__init__.py
index ebfb92c..32b780c 100644
--- a/varidex/core/classifier/__init__.py
+++ b/varidex/core/classifier/__init__.py
@@ -90,12 +90,12 @@
     HAS_V7 = True
 
     # Issue warning when V7 is imported
-        # warnings.warn(  # WARNING DISABLED FOR PRODUCTION
-        # "ACMGClassifierV7 is EXPERIMENTAL and not production-tested. "
-        # "Use ACMGClassifier for production. See VERSION_HISTORY.md for details.",
-        # UserWarning,
-        # stacklevel=2,
-        # )
+    # warnings.warn(  # WARNING DISABLED FOR PRODUCTION
+    # "ACMGClassifierV7 is EXPERIMENTAL and not production-tested. "
+    # "Use ACMGClassifier for production. See VERSION_HISTORY.md for details.",
+    # UserWarning,
+    # stacklevel=2,
+    # )
 except ImportError:
     # V7 requires gnomAD dependencies
     def ACMGClassifierV7(*args, **kwargs):
@@ -112,12 +112,12 @@ def ACMGClassifierV7(*args, **kwargs):
     HAS_V8 = True
 
     # Issue warning when V8 is imported
-        # warnings.warn(  # WARNING DISABLED FOR PRODUCTION
-        # "ACMGClassifierV8 is EXPERIMENTAL and not production-tested. "
-        # "Use ACMGClassifier for production. See VERSION_HISTORY.md for details.",
-        # UserWarning,
-        # stacklevel=2,
-        # )
+    # warnings.warn(  # WARNING DISABLED FOR PRODUCTION
+    # "ACMGClassifierV8 is EXPERIMENTAL and not production-tested. "
+    # "Use ACMGClassifier for production. See VERSION_HISTORY.md for details.",
+    # UserWarning,
+    # stacklevel=2,
+    # )
 except ImportError:
     # V8 requires gnomAD + SpliceAI + dbNSFP dependencies
     def ACMGClassifierV8(*args, **kwargs):
diff --git a/varidex/core/classifier/acmg_evidence_full.py b/varidex/core/classifier/acmg_evidence_full.py
index 41bd597..4ad862e 100644
--- a/varidex/core/classifier/acmg_evidence_full.py
+++ b/varidex/core/classifier/acmg_evidence_full.py
@@ -667,7 +667,7 @@ def bp6(self, clinvar_sig: str, data: DataRequirements) -> EvidenceResult:
 
         if is_benign:
             return EvidenceResult(
-                "BP6", True, f'ClinVar reports: {clinvar_sig or "benign"}', 0.75, True
+                "BP6", True, f"ClinVar reports: {clinvar_sig or 'benign'}", 0.75, True
             )
 
         return EvidenceResult("BP6", False, "No benign reports", 0.0, True)
diff --git a/varidex/core/classifier/config.py b/varidex/core/classifier/config.py
index c50d0ac..c574cd2 100644
--- a/varidex/core/classifier/config.py
+++ b/varidex/core/classifier/config.py
@@ -333,18 +333,18 @@ def get_performance_report(self) -> str:
 
         report: str = f"""
 ACMG Classifier Performance Report
-{'='*70}
-Total Classifications: {summary['total']:,}
-Success Rate: {summary['success_rate']*100:.1f}%
-Average Time: {summary['avg_time_ms']:.1f}ms
-Min/Max Time: {summary['min_time_ms']:.1f}ms / {summary['max_time_ms']:.1f}ms
+{"=" * 70}
+Total Classifications: {summary["total"]:,}
+Success Rate: {summary["success_rate"] * 100:.1f}%
+Average Time: {summary["avg_time_ms"]:.1f}ms
+Min/Max Time: {summary["min_time_ms"]:.1f}ms / {summary["max_time_ms"]:.1f}ms
 
 Classification Distribution:
-  • Pathogenic: {summary['classification_distribution'].get('Pathogenic', 0):,}
-  • Likely Pathogenic: {summary['classification_distribution'].get('Likely Pathogenic', 0):,}
-  • VUS: {summary['classification_distribution'].get('Uncertain Significance', 0):,}
-  • Likely Benign: {summary['classification_distribution'].get('Likely Benign', 0):,}
-  • Benign: {summary['classification_distribution'].get('Benign', 0):,}
+  • Pathogenic: {summary["classification_distribution"].get("Pathogenic", 0):,}
+  • Likely Pathogenic: {summary["classification_distribution"].get("Likely Pathogenic", 0):,}
+  • VUS: {summary["classification_distribution"].get("Uncertain Significance", 0):,}
+  • Likely Benign: {summary["classification_distribution"].get("Likely Benign", 0):,}
+  • Benign: {summary["classification_distribution"].get("Benign", 0):,}
 
 Top Evidence Codes:
 """
diff --git a/varidex/core/classifier/engine_v8.py b/varidex/core/classifier/engine_v8.py
index 87b8519..87c2364 100644
--- a/varidex/core/classifier/engine_v8.py
+++ b/varidex/core/classifier/engine_v8.py
@@ -280,9 +280,9 @@ def health_check(self) -> Dict[str, Any]:
 
         if self.prediction_service:
             try:
-                health["predictions"][
-                    "statistics"
-                ] = self.prediction_service.get_statistics()
+                health["predictions"]["statistics"] = (
+                    self.prediction_service.get_statistics()
+                )
             except Exception as e:
                 health["predictions"]["error"] = str(e)
 
diff --git a/varidex/core/config.py b/varidex/core/config.py
index 58cb60e..b18e4ac 100644
--- a/varidex/core/config.py
+++ b/varidex/core/config.py
@@ -402,8 +402,7 @@ def __init__(
         valid_log_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
         if log_level.upper() not in valid_log_levels:
             raise ValueError(
-                f"Invalid log level '{log_level}'. "
-                f"Must be one of {valid_log_levels}"
+                f"Invalid log level '{log_level}'. Must be one of {valid_log_levels}"
             )
         self.log_level = log_level.upper()
         self.debug_mode = bool(debug_mode)
diff --git a/varidex/core/exceptions.py b/varidex/core/exceptions.py
index 38d052e..0bb57c2 100644
--- a/varidex/core/exceptions.py
+++ b/varidex/core/exceptions.py
@@ -218,6 +218,6 @@ def validate_type(value: Any, expected_type: Type[Any], name: str) -> None:
         print("✓ Test 10: ConfigurationError alias works")
         passed += 1
 
-    print(f"\n{'='*70}")
+    print(f"\n{'=' * 70}")
     print(f"PASSED: {passed}/{total} tests")
     print("=" * 70)
diff --git a/varidex/core/models.py b/varidex/core/models.py
index 111a61b..7f688bc 100644
--- a/varidex/core/models.py
+++ b/varidex/core/models.py
@@ -498,8 +498,7 @@ def get_variant_notation(self) -> str:
         """Get standard variant notation (chr:pos:ref>alt)."""
         if self.ref_allele and self.alt_allele:
             return (
-                f"{self.chromosome}:{self.position}:"
-                f"{self.ref_allele}>{self.alt_allele}"
+                f"{self.chromosome}:{self.position}:{self.ref_allele}>{self.alt_allele}"
             )
         return f"{self.chromosome}:{self.position}"
 
diff --git a/varidex/core/models_back.py b/varidex/core/models_back.py
index 2034deb..ba0f082 100644
--- a/varidex/core/models_back.py
+++ b/varidex/core/models_back.py
@@ -412,8 +412,7 @@ def get_variant_notation(self) -> str:
         """Get standard variant notation (chr:pos:ref>alt)."""
         if self.ref_allele and self.alt_allele:
             return (
-                f"{self.chromosome}:{self.position}:"
-                f"{self.ref_allele}>{self.alt_allele}"
+                f"{self.chromosome}:{self.position}:{self.ref_allele}>{self.alt_allele}"
             )
         return f"{self.chromosome}:{self.position}"
 
diff --git a/varidex/integrations/gnomad_annotator.py b/varidex/integrations/gnomad_annotator.py
index a2c42d4..dc7fdac 100644
--- a/varidex/integrations/gnomad_annotator.py
+++ b/varidex/integrations/gnomad_annotator.py
@@ -211,7 +211,7 @@ def _apply_filters(self, df: pd.DataFrame) -> pd.DataFrame:
         if filtered_count > 0:
             logger.info(
                 f"   Filtered {filtered_count:,} variants "
-                f"({100*filtered_count/original_count:.1f}%)"
+                f"({100 * filtered_count / original_count:.1f}%)"
             )
 
         return df
@@ -236,7 +236,7 @@ def get_rare_variants(
 
         logger.info(
             f"Found {len(rare):,} rare variants "
-            f"(AF < {af_threshold*100:.2f}%) out of {len(df):,}"
+            f"(AF < {af_threshold * 100:.2f}%) out of {len(df):,}"
         )
 
         return rare
@@ -257,8 +257,7 @@ def get_novel_variants(self, df: pd.DataFrame) -> pd.DataFrame:
         novel = df[df["gnomad_af"].isna()]
 
         logger.info(
-            f"Found {len(novel):,} novel variants "
-            f"(not in gnomAD) out of {len(df):,}"
+            f"Found {len(novel):,} novel variants (not in gnomAD) out of {len(df):,}"
         )
 
         return novel
diff --git a/varidex/io/loaders/clinvar.py b/varidex/io/loaders/clinvar.py
index 76e2aed..b8212cb 100644
--- a/varidex/io/loaders/clinvar.py
+++ b/varidex/io/loaders/clinvar.py
@@ -394,9 +394,9 @@ def load_clinvar_vcf(
     checkpoint_dir: Optional[Path] = None,
 ) -> pd.DataFrame:
     """Load full ClinVar VCF with gene and molecular_consequence extraction."""
-    print(f"\n{'='*70}")
+    print(f"\n{'=' * 70}")
     print(f"📁 LOADING VCF: {filepath.name}")
-    print(f"{'='*70}")
+    print(f"{'=' * 70}")
 
     try:
         # Count lines for progress bar
@@ -472,7 +472,7 @@ def parse_info(info: Any) -> Dict[str, str]:
             rsid_count: int = df["rsid"].notna().sum()
             print(
                 f"  ✓ Extracted {rsid_count:,} rsIDs "
-                f"({100*rsid_count/len(df):.1f}%)\n"
+                f"({100 * rsid_count / len(df):.1f}%)\n"
             )
 
         # ✨ NEW: Extract GENE from INFO field (vectorized)
@@ -482,7 +482,7 @@ def parse_info(info: Any) -> Dict[str, str]:
             gene_count: int = df["gene"].notna().sum()
             print(
                 f"  ✓ Extracted {gene_count:,} gene names "
-                f"({100*gene_count/len(df):.1f}%)\n"
+                f"({100 * gene_count / len(df):.1f}%)\n"
             )
 
         # ✨ NEW: Extract MOLECULAR_CONSEQUENCE from INFO field (vectorized)
@@ -492,7 +492,7 @@ def parse_info(info: Any) -> Dict[str, str]:
             cons_count: int = df["molecular_consequence"].notna().sum()
             print(
                 f"  ✓ Extracted {cons_count:,} consequences "
-                f"({100*cons_count/len(df):.1f}%)\n"
+                f"({100 * cons_count / len(df):.1f}%)\n"
             )
 
             # Show top consequences
@@ -527,9 +527,9 @@ def parse_info(info: Any) -> Dict[str, str]:
         # Just normalize chromosome names (lightweight)
         df = validate_chromosome_consistency(df)
 
-        print(f"{'='*70}")
+        print(f"{'=' * 70}")
         print(f"✅ COMPLETE: {len(df):,} variants loaded")
-        print(f"{'='*70}\n")
+        print(f"{'=' * 70}\n")
 
         return df
     except Exception as e:
@@ -544,9 +544,9 @@ def load_clinvar_vcf_tsv(
     checkpoint_dir: Optional[Path] = None,
 ) -> pd.DataFrame:
     """Load VCF-style TSV with progress."""
-    print(f"\n{'='*70}")
+    print(f"\n{'=' * 70}")
     print(f"📁 LOADING VCF-TSV: {filepath.name}")
-    print(f"{'='*70}\n")
+    print(f"{'=' * 70}\n")
 
     try:
         print("📖 Reading TSV data...")
@@ -596,9 +596,9 @@ def load_clinvar_vcf_tsv(
             print(f"  Deduped: {orig_len:,} → {len(df):,}")
         print(f"  ✓ {len(df):,} variants\n")
 
-        print(f"{'='*70}")
+        print(f"{'=' * 70}")
         print(f"✅ COMPLETE: {len(df):,} variants loaded")
-        print(f"{'='*70}\n")
+        print(f"{'=' * 70}\n")
 
         return df
     except Exception as e:
@@ -614,9 +614,9 @@ def load_variant_summary(
     checkpoint_dir: Optional[Path] = None,
 ) -> pd.DataFrame:
     """Load variant_summary.txt with progress."""
-    print(f"\n{'='*70}")
+    print(f"\n{'=' * 70}")
     print(f"📁 LOADING VARIANT_SUMMARY: {filepath.name}")
-    print(f"{'='*70}\n")
+    print(f"{'=' * 70}\n")
 
     try:
         print("🔍 Detecting separator...")
@@ -695,9 +695,9 @@ def load_variant_summary(
             df = validate_position_ranges_parallel(df)
             print("  ✓ Validated\n")
 
-        print(f"{'='*70}")
+        print(f"{'=' * 70}")
         print(f"✅ COMPLETE: {len(df):,} variants loaded")
-        print(f"{'='*70}\n")
+        print(f"{'=' * 70}\n")
 
         return df
     except Exception as e:
diff --git a/varidex/io/loaders/clinvar_gpu.py b/varidex/io/loaders/clinvar_gpu.py
index 77a6628..5afb326 100644
--- a/varidex/io/loaders/clinvar_gpu.py
+++ b/varidex/io/loaders/clinvar_gpu.py
@@ -9,6 +9,7 @@
 - Vectorized INFO field extraction
 - GPU rsID matching
 """
+
 import cudf
 from nvtabular import VCFLoader  # GPU VCF reader
 
diff --git a/varidex/io/loaders/gnomad.py b/varidex/io/loaders/gnomad.py
index d50bece..27d1388 100644
--- a/varidex/io/loaders/gnomad.py
+++ b/varidex/io/loaders/gnomad.py
@@ -572,7 +572,7 @@ def annotate_dataframe(
         found = sum(1 for f in frequencies if f is not None)
         print(
             f"  ✓ Found gnomAD data for {found:,}/{len(df):,} variants "
-            f"({100*found/len(df):.1f}%)\n"
+            f"({100 * found / len(df):.1f}%)\n"
         )
 
         return result
diff --git a/varidex/io/loaders/vcfloader.py b/varidex/io/loaders/vcfloader.py
index b5da673..66a0fbd 100644
--- a/varidex/io/loaders/vcfloader.py
+++ b/varidex/io/loaders/vcfloader.py
@@ -96,4 +96,4 @@ def load_vcf_chunked(
                 "alternate": ["G"] * size,
             }
         )
-        logger.debug(f"Mock chunk {i//chunk_size}: {size} variants")
+        logger.debug(f"Mock chunk {i // chunk_size}: {size} variants")
diff --git a/varidex/io/matching_improved.py b/varidex/io/matching_improved.py
index 1331f28..da6d725 100644
--- a/varidex/io/matching_improved.py
+++ b/varidex/io/matching_improved.py
@@ -61,8 +61,7 @@ def get_user_chromosomes(user_df: pd.DataFrame) -> Set[str]:
         return set([str(i) for i in range(1, 23)] + ["X", "Y", "MT"])
 
     logger.info(
-        f"User genome contains {len(standardized)} chromosomes: "
-        f"{sorted(standardized)}"
+        f"User genome contains {len(standardized)} chromosomes: {sorted(standardized)}"
     )
 
     return standardized
@@ -322,9 +321,9 @@ def match_variants_hybrid(
     if clinvar_df is None or len(clinvar_df) == 0:
         raise ValueError("ClinVar DataFrame is empty")
 
-    logger.info(f"{'='*60}")
+    logger.info(f"{'=' * 60}")
     logger.info(f"MATCHING: {clinvar_type} × {user_type}")
-    logger.info(f"{'='*60}")
+    logger.info(f"{'=' * 60}")
 
     matches: List[pd.DataFrame] = []
     rsid_count: int = 0
@@ -369,7 +368,7 @@ def match_variants_hybrid(
     combined = deduplicate_matches(combined, strategy="best")
 
     coverage = len(combined) / len(user_df) * 100
-    logger.info(f"{'='*60}")
+    logger.info(f"{'=' * 60}")
     logger.info(f"TOTAL: {len(combined):,} matches ({coverage:.1f}% coverage)")
 
     # Show confidence distribution
@@ -405,7 +404,7 @@ def match_variants_hybrid(
     logger.info(
         f"Consolidated chromosome: {combined['chromosome'].notna().sum()}/{len(combined)} values"
     )
-    logger.info(f"{'='*60}")
+    logger.info(f"{'=' * 60}")
 
     return combined, rsid_count, coord_count
 
diff --git a/varidex/pipeline/__main__.py b/varidex/pipeline/__main__.py
index a9dd495..417d7f1 100644
--- a/varidex/pipeline/__main__.py
+++ b/varidex/pipeline/__main__.py
@@ -80,22 +80,49 @@ def write_output_files(df: pd.DataFrame, output_dir: Path) -> None:
 
     # All 21 implemented ACMG codes
     acmg_codes = [
-        "BA1", "BS1", "PM2",
-        "PVS1", "PM4", "PP2", "BP1", "BP3",
-        "PP5", "BP6", "BP7", "BS2", "BS3",
-        "PM1", "PM5", "PM3", "PS1",
-        "PS3", "PP3", "BA4", "BP2", "BP4",
+        "BA1",
+        "BS1",
+        "PM2",
+        "PVS1",
+        "PM4",
+        "PP2",
+        "BP1",
+        "BP3",
+        "PP5",
+        "BP6",
+        "BP7",
+        "BS2",
+        "BS3",
+        "PM1",
+        "PM5",
+        "PM3",
+        "PS1",
+        "PS3",
+        "PP3",
+        "BA4",
+        "BP2",
+        "BP4",
     ]
 
     essentials = [
-        "rsid", "chromosome", "position", "genotype", "gene",
-        "clinical_sig", "review_status", "molecular_consequence",
-        "gnomad_af", "acmg_classification",
+        "rsid",
+        "chromosome",
+        "position",
+        "genotype",
+        "gene",
+        "clinical_sig",
+        "review_status",
+        "molecular_consequence",
+        "gnomad_af",
+        "acmg_classification",
     ]
 
     pred_scores = [
-        "SIFT_score", "PolyPhen_score", "CADD_phred",
-        "REVEL_score", "AlphaMissense_score",
+        "SIFT_score",
+        "PolyPhen_score",
+        "CADD_phred",
+        "REVEL_score",
+        "AlphaMissense_score",
     ]
 
     export_base = essentials + acmg_codes + pred_scores
@@ -216,7 +243,9 @@ def print_acmg_summary(df: pd.DataFrame) -> tuple:
             count = pathogenic_counts[code]
             pct = (count / total_variants * 100) if total_variants > 0 else 0.0
             if count > 0:
-                print(f"   ✅ {code:6s}: {count:5,d} variants ({pct:5.2f}%) - {description}")
+                print(
+                    f"   ✅ {code:6s}: {count:5,d} variants ({pct:5.2f}%) - {description}"
+                )
             else:
                 print(f"   ⚪ {code:6s}:     0 variants ( 0.00%) - {description}")
         else:
@@ -230,7 +259,9 @@ def print_acmg_summary(df: pd.DataFrame) -> tuple:
             count = benign_counts[code]
             pct = (count / total_variants * 100) if total_variants > 0 else 0.0
             if count > 0:
-                print(f"   ✅ {code:6s}: {count:5,d} variants ({pct:5.2f}%) - {description}")
+                print(
+                    f"   ✅ {code:6s}: {count:5,d} variants ({pct:5.2f}%) - {description}"
+                )
             else:
                 print(f"   ⚪ {code:6s}:     0 variants ( 0.00%) - {description}")
         else:
@@ -248,7 +279,9 @@ def print_acmg_summary(df: pd.DataFrame) -> tuple:
     print()
     print("=" * 80)
     print(f"📊 Total Evidence Applied: {total_with_evidence:,} criterion applications")
-    print(f"   Active criteria: {active_criteria}/{implemented_criteria} ({active_criteria/implemented_criteria*100:.1f}%)")
+    print(
+        f"   Active criteria: {active_criteria}/{implemented_criteria} ({active_criteria / implemented_criteria * 100:.1f}%)"
+    )
 
     return active_criteria, implemented_criteria
 
@@ -258,15 +291,37 @@ def print_summary(df: pd.DataFrame) -> None:
 
     # Count criteria
     all_criteria = [
-        "PVS1", "PS1", "PS3", "PM1", "PM2", "PM3", "PM4", "PM5", "PP2", "PP3", "PP5",
-        "BA1", "BA4", "BS1", "BS2", "BS3", "BP1", "BP2", "BP3", "BP4", "BP6", "BP7",
+        "PVS1",
+        "PS1",
+        "PS3",
+        "PM1",
+        "PM2",
+        "PM3",
+        "PM4",
+        "PM5",
+        "PP2",
+        "PP3",
+        "PP5",
+        "BA1",
+        "BA4",
+        "BS1",
+        "BS2",
+        "BS3",
+        "BP1",
+        "BP2",
+        "BP3",
+        "BP4",
+        "BP6",
+        "BP7",
     ]
 
     active_count = sum(1 for c in all_criteria if c in df.columns and df[c].sum() > 0)
     implemented_count = sum(1 for c in all_criteria if c in df.columns)
 
     print("\n" + "=" * 80)
-    print(f"PIPELINE COMPLETE - {active_count} Active / {implemented_count} Implemented (of 28 ACMG)")
+    print(
+        f"PIPELINE COMPLETE - {active_count} Active / {implemented_count} Implemented (of 28 ACMG)"
+    )
     print("=" * 80)
     print(f"Total variants: {len(df):,}")
 
@@ -302,8 +357,21 @@ def print_summary(df: pd.DataFrame) -> None:
 
     # Evidence coverage
     evidence_cols = [
-        "BA1", "BS1", "PM2", "PVS1", "BP7", "PP5", "BP6", "BS2",
-        "PM1", "PM5", "PS1", "PS3", "PP3", "BP4", "BA4",
+        "BA1",
+        "BS1",
+        "PM2",
+        "PVS1",
+        "BP7",
+        "PP5",
+        "BP6",
+        "BS2",
+        "PM1",
+        "PM5",
+        "PS1",
+        "PS3",
+        "PP3",
+        "BP4",
+        "BA4",
     ]
     existing_cols = [c for c in evidence_cols if c in df.columns]
 
@@ -315,7 +383,7 @@ def print_summary(df: pd.DataFrame) -> None:
 
     print(
         f"\n📊 Evidence Coverage: {with_evidence:,}/{len(df):,} "
-        f"({with_evidence/len(df)*100:.1f}%)"
+        f"({with_evidence / len(df) * 100:.1f}%)"
     )
 
     # Print detailed criteria summary
@@ -332,7 +400,7 @@ def print_summary(df: pd.DataFrame) -> None:
         if high_risk > 0:
             print(
                 f"\n⚠️  High-Risk Variants (PVS1/PS3 or PM2+PP3): {high_risk:,} "
-                f"({high_risk/len(df)*100:.1f}%)"
+                f"({high_risk / len(df) * 100:.1f}%)"
             )
 
 
diff --git a/varidex/pipeline/gnomad_annotator_parallel.py b/varidex/pipeline/gnomad_annotator_parallel.py
index 7e83329..45fc826 100644
--- a/varidex/pipeline/gnomad_annotator_parallel.py
+++ b/varidex/pipeline/gnomad_annotator_parallel.py
@@ -102,7 +102,7 @@ def annotate_with_gnomad_parallel(
 
     found_count = result["gnomad_af"].notna().sum()
     logger.info(
-        f"✓ gnomAD annotation complete: {found_count:,}/{len(df):,} ({100*found_count/len(df):.1f}%) variants found"
+        f"✓ gnomAD annotation complete: {found_count:,}/{len(df):,} ({100 * found_count / len(df):.1f}%) variants found"
     )
 
     return result
diff --git a/varidex/pipeline/gnomad_annotator_parallel_FAST.py b/varidex/pipeline/gnomad_annotator_parallel_FAST.py
index 7e83329..45fc826 100644
--- a/varidex/pipeline/gnomad_annotator_parallel_FAST.py
+++ b/varidex/pipeline/gnomad_annotator_parallel_FAST.py
@@ -102,7 +102,7 @@ def annotate_with_gnomad_parallel(
 
     found_count = result["gnomad_af"].notna().sum()
     logger.info(
-        f"✓ gnomAD annotation complete: {found_count:,}/{len(df):,} ({100*found_count/len(df):.1f}%) variants found"
+        f"✓ gnomAD annotation complete: {found_count:,}/{len(df):,} ({100 * found_count / len(df):.1f}%) variants found"
     )
 
     return result
diff --git a/varidex/pipeline/gnomad_gpu.py b/varidex/pipeline/gnomad_gpu.py
index cf56738..9d90cc3 100644
--- a/varidex/pipeline/gnomad_gpu.py
+++ b/varidex/pipeline/gnomad_gpu.py
@@ -9,6 +9,7 @@
 - Batch frequency lookup
 - GPU BA1/BS1/PM2 calculation
 """
+
 import cudf
 import cuml.ensemble.RandomForestClassifier  # GPU ML
 
diff --git a/varidex/pipeline/gnomad_stage.py b/varidex/pipeline/gnomad_stage.py
index 8d5892c..96eee23 100644
--- a/varidex/pipeline/gnomad_stage.py
+++ b/varidex/pipeline/gnomad_stage.py
@@ -4,6 +4,7 @@
 Copy-paste this entire file to replace varidex/pipeline/gnomad_stage.py
 Black-formatted, production-ready, no raw data changes.
 """
+
 from __future__ import annotations
 from pathlib import Path
 from typing import Optional
diff --git a/varidex/pipeline/orchestrator.py b/varidex/pipeline/orchestrator.py
index 77f66db..1c1285e 100644
--- a/varidex/pipeline/orchestrator.py
+++ b/varidex/pipeline/orchestrator.py
@@ -98,7 +98,7 @@ def simple_hybrid_matching(
 def main(clinvar_path: str, user_data_path: str, **kwargs) -> bool:
     """🚀 COMPLETE 7-STAGE PRODUCTION PIPELINE."""
     print("\n🚀 VariDex v8.2.5 - PRODUCTION PIPELINE")
-    print(f"{'='*65}")
+    print(f"{'=' * 65}")
 
     # Paths
     clinvar_file = Path(clinvar_path)
@@ -175,7 +175,7 @@ def main(clinvar_path: str, user_data_path: str, **kwargs) -> bool:
     print(f"  ✓ 03_top_pathogenic.csv ({pathogenic:,} total)")
 
     print(f"\n🎉 PIPELINE 100% COMPLETE!")
-    print(f"{'='*65}")
+    print(f"{'=' * 65}")
     print(f"📈 SUMMARY:")
     print(f"   User variants:     {len(user_df):,}")
     print(f"   Matches:           {len(matches):,} ({match_rate:.1f}%)")
diff --git a/varidex/pipeline/pipeline_config.py b/varidex/pipeline/pipeline_config.py
index 2c41911..fdd50cb 100644
--- a/varidex/pipeline/pipeline_config.py
+++ b/varidex/pipeline/pipeline_config.py
@@ -90,8 +90,7 @@ def _validate_safeguard_config(cfg: Dict[str, Any]) -> None:
 
     if cfg["clinvar_max_age_days"] < 0:
         raise ValueError(
-            f"clinvar_max_age_days must be positive, "
-            f"got {cfg['clinvar_max_age_days']}"
+            f"clinvar_max_age_days must be positive, got {cfg['clinvar_max_age_days']}"
         )
 
 
diff --git a/varidex/pipeline_config.py b/varidex/pipeline_config.py
index bb07c81..b8495ee 100644
--- a/varidex/pipeline_config.py
+++ b/varidex/pipeline_config.py
@@ -91,8 +91,7 @@ def _validate_safeguard_config(cfg: Dict[str, Any]) -> None:
 
     if cfg["clinvar_max_age_days"] < 0:
         raise ValueError(
-            f"clinvar_max_age_days must be positive, "
-            f"got {cfg['clinvar_max_age_days']}"
+            f"clinvar_max_age_days must be positive, got {cfg['clinvar_max_age_days']}"
         )
 
 
diff --git a/varidex/pipeline_main_integrated.py b/varidex/pipeline_main_integrated.py
index cd260a1..23ac45c 100644
--- a/varidex/pipeline_main_integrated.py
+++ b/varidex/pipeline_main_integrated.py
@@ -204,7 +204,7 @@ def run_pipeline_integrated(
     print("📊 Results:")
     print(f"  Total variants: {len(final_df):,}")
     print(
-        f"  With evidence: {with_evidence:,} ({with_evidence/len(final_df)*100:.1f}%)"
+        f"  With evidence: {with_evidence:,} ({with_evidence / len(final_df) * 100:.1f}%)"
     )
     print(f"  Pathogenic: {pathogenic_count:,}")
     print()
diff --git a/varidex/reports/generator.py b/varidex/reports/generator.py
index abafbe5..09c83d4 100644
--- a/varidex/reports/generator.py
+++ b/varidex/reports/generator.py
@@ -494,7 +494,7 @@ def generate_all_reports(
         >>> print(reports['csv'])
         out/classified_variants_20260119_205600.csv
     """
-    logger.info(f"\n{'='*70}\nGENERATING REPORTS\n{'='*70}")
+    logger.info(f"\n{'=' * 70}\nGENERATING REPORTS\n{'=' * 70}")
     start_time = time.time()
 
     if not FORMATTERS_AVAILABLE:
@@ -581,7 +581,7 @@ def generate_all_reports(
     logger.info(
         f"\n✅ Generated {len(generated)}/{requested} report(s) in {elapsed:.2f}s"
     )
-    logger.info(f"{'='*70}\n")
+    logger.info(f"{'=' * 70}\n")
 
     return generated
 
diff --git a/varidex/utils/liftover.py b/varidex/utils/liftover.py
index 0f5a853..79742d0 100755
--- a/varidex/utils/liftover.py
+++ b/varidex/utils/liftover.py
@@ -120,8 +120,12 @@ def liftover_23andme(
     print(f"\n📊 Liftover Summary:")
     print(f"   Total variants:     {total:,}")
     print(f"   Valid for liftover: {len(df_clean):,}")
-    print(f"   Successful lifts:   {success_count:,} ({success_count/total*100:.1f}%)")
-    print(f"   Failed lifts:       {failed_count:,} ({failed_count/total*100:.1f}%)")
+    print(
+        f"   Successful lifts:   {success_count:,} ({success_count / total * 100:.1f}%)"
+    )
+    print(
+        f"   Failed lifts:       {failed_count:,} ({failed_count / total * 100:.1f}%)"
+    )
     print(f"\n💾 Output saved: {output_file}")
 
     return total, success_count, failed_count