md files

Populated the right_wing_motions.category column (previously 100% NULL across
3,030 motions) via parallel subagent classification — 80 agents derived a
10-category taxonomy and classified all motions in minutes.

Adds to the Overton QMD report:
- Plotly dropdown filter on Chart 1 to toggle between policy categories
- Chart 7: category delta bar chart (pre/post centrist support per domain)
- Chart 8: quarterly domain trajectories for the 5 largest categories
- Domain Decomposition narrative section

Also fixes a Streamlit tab crash (m.text -> m.body_text) and adds TDD tests.

.compound-engineering/config.local.example.yaml

@@ -0,0 +1,12 @@
+# Compound Engineering -- local config
+# Copy to .compound-engineering/config.local.yaml in your project root.
+# All settings are optional. Invalid values fall through to defaults.
+
+# --- Work delegation (Codex) ---
+
+# work_delegate: codex           # codex | false (default: false)
+# work_delegate_consent: true    # true | false (default: false)
+# work_delegate_sandbox: yolo    # yolo | full-auto (default: yolo)
+# work_delegate_decision: auto   # auto | ask (default: auto)
+# work_delegate_model: gpt-5.4  # any valid codex model (default: gpt-5.4)
+# work_delegate_effort: high     # minimal | low | medium | high | xhigh (default: high)

.github/workflows/ci-node-packages.yml

@@ -1,52 +0,0 @@
-name: CI — Node packages
-
-on:
-  push:
-    paths:
-      - 'packages/**'
-  pull_request:
-    paths:
-      - 'packages/**'
-
-jobs:
-  test-packages:
-    name: Test packages/*
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-
-      - name: Run tests for each package
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          # Find all package directories under packages/ that contain a package.json
-          packages=(packages/*)
-          found=0
-
-          for p in "${packages[@]}"; do
-            if [ -d "$p" ] && [ -f "$p/package.json" ]; then
-              found=1
-              echo "\n===== Package: $p ====="
-
-              echo "-> Installing dependencies in $p"
-              (cd "$p" && npm ci) || (cd "$p" && npm install)
-
-              echo "-> Running tests in $p"
-              (cd "$p" && npm test)
-
-              echo "-> Running pack-inspect in $p"
-              (cd "$p" && npm run pack-inspect)
-            fi
-          done
-
-          if [ "$found" -eq 0 ]; then
-            echo "No packages with package.json found under packages/"
-          fi

.github/workflows/mindmodel-schedule.yml

@@ -1,35 +0,0 @@
-name: mindmodel scheduled validate
-
-on:
-  schedule:
-    - cron: '0 0 * * 0' # weekly
-
-jobs:
-  validate:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: '3.11'
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements.txt || true
-
-      - name: Run tests
-        run: |
-          python -m pytest -q
-
-      - name: Run mindmodel validator if manifest exists
-        if: ${{ always() }}
-        run: |
-          if [ -f .mindmodel/manifest.yaml ]; then
-            python -m scripts.mindmodel.cli || true
-          else
-            echo "No .mindmodel/manifest.yaml present — skipping validator"
-          fi

.github/workflows/mindmodel-validation.yml

@@ -1,47 +0,0 @@
-name: mindmodel validation
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  validate:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: '3.x'
-
-      - name: Install development dependencies (if present)
-        run: |
-          python -m pip install --upgrade pip
-          if [ -f requirements-dev.txt ]; then
-            pip install -r requirements-dev.txt
-          else
-            echo "requirements-dev.txt not found, skipping"
-          fi
-
-      - name: Run mindmodel validator (report-only)
-        if: ${{ always() }}
-        run: |
-          # Make this step report-only: run the validator but always exit 0 so PRs are not blocked
-          set +e
-          if [ -f .mindmodel/manifest.yaml ]; then
-            python scripts/validate_mindmodel.py --manifest .mindmodel/manifest.yaml --report reports/out.json || true
-          else
-            echo "No .mindmodel/manifest.yaml present — skipping validator"
-          fi
-          exit 0
-
-      - name: Upload mindmodel reports
-        if: ${{ always() }}
-        uses: actions/upload-artifact@v4
-        with:
-          name: mindmodel-reports
-          path: reports/mindmodel-report-*.json

.github/workflows/publish-ansible-example.yml

@@ -1,77 +0,0 @@
-name: Publish Ansible Example
-
-on:
-  push:
-    tags:
-      - 'v*'
-  workflow_dispatch: {}
-
-jobs:
-  verify:
-    name: Verify package
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js 18
-        uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-
-      - name: Install dependencies (packages/@ansible/example)
-        working-directory: packages/@ansible/example
-        run: |
-          # prefer CI install when a lockfile exists, otherwise fall back to install
-          if [ -f package-lock.json ] || [ -f pnpm-lock.yaml ] || [ -f yarn.lock ]; then
-            npm ci
-          else
-            npm install
-          fi
-
-      - name: Run tests
-        working-directory: packages/@ansible/example
-        run: npm test
-
-      - name: Run pack-inspect
-        working-directory: packages/@ansible/example
-        run: npm run pack-inspect
-
-  publish:
-    name: Publish to npm
-    runs-on: ubuntu-latest
-    needs: verify
-    if: ${{ ((github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')) || (github.event_name == 'workflow_dispatch')) && (secrets.NPM_TOKEN != '') }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js 18
-        uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-
-      - name: Create ephemeral .npmrc with token
-        run: |
-          set -euo pipefail
-          # write token to a temporary npmrc with restricted permissions (0600)
-          printf "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}\n" > ~/.npmrc
-          chmod 600 ~/.npmrc
-
-      - name: Publish package
-        working-directory: packages/@ansible/example
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: |
-          set -euo pipefail
-          # publish publicly; rely on npmrc for auth
-          npm publish --access public
-
-      - name: Remove ephemeral .npmrc (always)
-        if: always()
-        run: |
-          set -euo pipefail
-          # attempt secure removal, fall back to plain removal
-          if [ -f ~/.npmrc ]; then
-            shred -u -z ~/.npmrc 2>/dev/null || rm -f ~/.npmrc || true
-          fi

.github/workflows/pytest.yml

@@ -0,0 +1,53 @@
+name: Pytest
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.6.x"
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install dependencies
+        run: uv sync --locked
+
+      - name: Run tests
+        run: uv run pytest tests/ -q
+
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.6.x"
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install dependencies
+        run: uv sync --locked
+
+      - name: Run pyright
+        continue-on-error: true
+        run: uv run pyright

.gitignore

@@ -14,11 +14,19 @@ data/*.db
 data/*.bak
 data/*.json
 
-# Generated output files
-outputs/
-outputs_*/
-
 # Stray temp files
 dummy
 
 .env
+
+# Worktrees
+.worktrees/
+
+# Generated analysis files
+thoughts/explorer/*.json
+thoughts/explorer/*_report.md
+
+# Compound Engineering local config
+.compound-engineering/*.local.yaml
+Backfill data
+stemwijzer.db

.mindmodel/README.md

@@ -1,11 +0,0 @@
-# .mindmodel
-
-This directory contains a generated, read-only snapshot of the repository's "mind model" — structured metadata and evidence used by tooling to reason about repository intent, patterns, and decisions.
-
-Guidelines
-- Read-only: Treat files in this directory as generated artifacts. Local tooling or CI may regenerate or validate them; avoid manual edits unless you are intentionally updating the generator.
-- No secrets: Do not place any credentials, tokens, or sensitive data here. The validator that consumes this folder is designed to detect common secret patterns and will fail if secrets are found.
-- Safe to read: Tools and CI may read these files. They must avoid opening or parsing arbitrary repository secrets and should operate in read-only mode.
-- Validation: CI workflows will run a validator against this folder (if present) to ensure manifest shape, evidence snippets, and referenced files meet project rules.
-
-If you need to propose a change to the mind model, open a PR describing the intent and the generator changes. The CI validator will validate the submitted artifact before merge.

.mindmodel/anti-patterns.yaml

@@ -1,43 +0,0 @@
-# Known anti-patterns and recommended remediation (Phase 1 findings)
-
-anti_patterns:
-  - id: broad_except_swallows_errors
-    description: "Wide except: clauses that swallow exceptions without logging or re-raising."
-    examples:
-      - path: multiple
-        note: "Observed in various pipeline and ingestion spots where except Exception: returns a default without context."
-    remediation:
-      - "Replace broad except with specific exceptions."
-      - "When broad except is absolutely needed, call logger.exception(...) and re-raise or convert to a typed domain error."
-      - "Add unit tests to ensure critical errors are visible in CI logs."
-
-  - id: mixed_print_and_logging
-    description: "Mixing print() and logging() for errors and info messages."
-    examples:
-      - path: api_client.py
-        excerpt: |
-          ```python
-          print(f"Fetched {len(voting_records)} voting records from API")
-          ...
-          except Exception as e:
-              print(f"Error fetching motions from API: {e}")
-          ```
-    remediation:
-      - "Use logging.getLogger(__name__) and logger.info/warning/exception consistently."
-      - "Add a top-level logging configuration for Streamlit and scripts."
-
-  - id: no_lockfile
-    description: "No lockfile present -> unreproducible installs and CI unpredictability."
-    remediation:
-      - "Add a lockfile (poetry.lock, requirements.txt produced by pip-tools) and pin versions in CI."
-      - "Make CI use the lockfile for reproducible builds."
-
-  - id: declared_but_unused_dependency
-    description: "Dependency declared but unused (openai in pyproject)."
-    remediation:
-      - "Either remove the dependency or add clear adapter code/tests that exercise it. Keep pyproject tidy."
-
-  - id: brittle_identity_heuristics
-    description: "Heuristics for MP identity (comma-based parsing) are brittle."
-    remediation:
-      - "Add robust parsing rules and unit tests; prefer canonical identifiers (persoon_id) where available."

.mindmodel/architecture.yaml

@@ -1,35 +0,0 @@
-# Architecture overview and confidence levels
-
-layers:
-  - name: ui
-    description: "Streamlit pages and app entrypoints (Home.py, pages/*)."
-    confidence: high
-  - name: ingestion
-    description: "API client and scrapers (api_client.py, scraper.py)."
-    confidence: high
-  - name: processing
-    description: "Pipelines for embeddings, SVD, fusion (pipeline/*, similarity/*)."
-    confidence: high
-  - name: storage
-    description: "DuckDB primary store; JSON fallback used in tests when duckdb missing."
-    confidence: high
-  - name: ai_provider
-    description: "Lightweight HTTP wrapper around OpenRouter/OpenAI-style backends in ai_provider.py."
-    confidence: medium
-  - name: orchestration
-    description: "Script-based orchestration (scripts/*.py), rerun_embeddings, scheduler."
-    confidence: medium
-
-organization:
-  - Keep UI code separated from heavy compute — Streamlit runs should avoid heavy compute inline (use subprocess or schedule).
-  - Pipelines are implemented as re-entrant functions returning summary dicts to facilitate testing and subprocess usage (seen in svd_pipeline.compute_svd_for_window).
-  - DB access is centralised via MotionDatabase helper (database.py) with convenience methods (store_fused_embedding, append_audit_event).
-
-design_decisions:
-  - Use DuckDB for local fast analytics storage; read_only connections used in compute stages to allow parallel workers.
-  - Embeddings and similarity cache are stored as JSON in DuckDB tables (vector columns).
-  - The ai_provider uses requests with retry/backoff rather than a heavy SDK to keep testing simple.
-
-confidence_summary:
-  overall_confidence: high
-  notes: "Phase 1 input inspected files across the repo; design mapping is consistent with code samples."

.mindmodel/constraints/01-naming.yaml

@@ -1,34 +0,0 @@
-# Naming & Style Conventions
-
-## Rules
-- Modules and files: snake_case.py. Evidence: pipeline/run_pipeline.py, database.py, ai_provider.py
-- Functions and methods: snake_case. Evidence: compute_svd_for_window (pipeline), _generate_windows (pipeline/run_pipeline.py)
-- Classes: PascalCase. Evidence: MotionDatabase (database.py)
-- Constants: UPPER_SNAKE_CASE. Evidence: VOTE_MAP, DATABASE_PATH (config inferred)
-- Imports order: stdlib, third-party, local; prefer absolute imports and grouped.
-- Use black, ruff, isort, mypy as the recommended toolchain; repository lacks config files (black, ruff, pyproject sections).
-
-## Examples
-
-### Function example (from pipeline/run_pipeline.py)
-```python
-def _generate_windows(start: date, end: date, granularity: str) -> List[Tuple[str, str, str]]:
-    """Return list of (window_id, start_str, end_str) tuples."""
-```
-
-### Class example (from database.py)
-```python
-class MotionDatabase:
-    def __init__(self, db_path: str = config.DATABASE_PATH):
-        ...
-```
-
-## Anti-patterns
-- Missing formatting configs (black, ruff, isort). Add pyproject.toml sections or dedicated config files.
-
-## Remediations
-- Add pyproject.toml tool sections for black/ruff/isort and a pre-commit config. Run ruff/black CI lint step.
-
-## Evidence pointers
-- pipeline/run_pipeline.py: function _generate_windows (lines ~1-120)
-- database.py: MotionDatabase class and methods (file database.py lines 1-400+)

.mindmodel/constraints/10-db-schema.yaml

@@ -1,74 +0,0 @@
-# Database Schema (DuckDB) — extracted DDL
-
-## Rules
-- Use DuckDB for persistent storage when available; fallback to JSON files when duckdb is not installed (database.py). 
-- Keep schema migrations additive (ALTER TABLE ADD COLUMN IF NOT EXISTS used in database.py).
-
-## Examples (DDL snippets extracted from database.py)
-
-### motions table
-```sql
-CREATE TABLE IF NOT EXISTS motions (
-    id INTEGER DEFAULT nextval('motions_id_seq'),
-    title TEXT NOT NULL,
-    description TEXT,
-    date DATE,
-    policy_area TEXT,
-    voting_results JSON,
-    winning_margin FLOAT,
-    controversy_score FLOAT,
-    layman_explanation TEXT,
-    externe_identifier TEXT,
-    body_text TEXT,
-    url TEXT UNIQUE,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY (id)
-)
-```
-
-### mp_votes table
-```sql
-CREATE TABLE IF NOT EXISTS mp_votes (
-    id INTEGER DEFAULT nextval('mp_votes_id_seq'),
-    motion_id INTEGER NOT NULL,
-    mp_name TEXT NOT NULL,
-    party TEXT,
-    vote TEXT NOT NULL,
-    date DATE,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY (id)
-)
-```
-
-### embeddings / fused_embeddings
-```sql
-CREATE TABLE IF NOT EXISTS embeddings (
-    id INTEGER DEFAULT nextval('embeddings_id_seq'),
-    motion_id INTEGER NOT NULL,
-    model TEXT,
-    vector JSON NOT NULL,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY (id)
-)
-
-CREATE TABLE IF NOT EXISTS fused_embeddings (
-    id INTEGER DEFAULT nextval('fused_embeddings_id_seq'),
-    motion_id INTEGER NOT NULL,
-    window_id TEXT NOT NULL,
-    vector JSON NOT NULL,
-    svd_dims INTEGER NOT NULL,
-    text_dims INTEGER NOT NULL,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY (id)
-)
-```
-
-## Anti-patterns
-- Broad try/except around duckdb import (database.py top) — acceptable for optional dependency but should log explicitly the missing dependency and document test behavior.
-
-## Remediations
-- Add a simple migration/versioning table (schema_version) to track schema changes and apply migrations deterministically.
-- Add tests that exercise both duckdb-backed and JSON-fallback database paths. Evidence: database.py contains JSON fallback logic (lines ~1-80).
-
-## Evidence pointers
-- database.py: DDL strings and sequences (file: database.py lines ~1-300 and further). See create table blocks for motions, mp_votes, embeddings, fused_embeddings.

.mindmodel/constraints/20-domain-glossary.yaml

@@ -1,22 +0,0 @@
-# Domain Glossary
-
-## Rules
-- Use consistent domain terms across code and DB: Motion, MP, Party, embedding, window, svd_vector, fused_embedding, similarity_cache, session_id.
-
-## Terms
-- Motion: parliamentary motion stored in `motions` table. Evidence: database.py CREATE TABLE motions (file: database.py lines ~40-110)
-- MP (Member of Parliament): individual with votes stored in `mp_votes`. Evidence: database.py CREATE TABLE mp_votes
-- Embedding: text embedding stored in `embeddings` table; fused vectors in `fused_embeddings`.
-- SVD vector: reduced-dimensional vectors stored in `svd_vectors` table.
-- Window: time window identifier (e.g., "2024-Q1") used across SVD/fusion pipelines. Evidence: pipeline/run_pipeline.py _generate_windows
-- Controversy score: derived field stored on motions as controversy_score. Evidence: database.py insert_motion sets controversy_score
-
-## Examples / Usage
-- pipeline.run_pipeline._generate_windows produces window ids used when storing svd_vectors and fused_embeddings. Evidence: pipeline/run_pipeline.py lines ~1-120
-
-## Evidence pointers
-- database.py: motions, mp_votes, embeddings, fused_embeddings tables (file: database.py)
-- pipeline/run_pipeline.py: window generation and pipeline phases (file: pipeline/run_pipeline.py)
-
-## Anti-patterns
-- Inconsistent naming of domain terms across modules (e.g., `mp_vote_parties` vs `mp_votes` usage in database.insert_motion and pipeline extraction). Prefer canonical names matching DB columns and use small adapter functions when transitioning representations.

.mindmodel/constraints/30-clusters.yaml

@@ -1,30 +0,0 @@
-# Code Clusters / Organization
-
-## Rules
-- The repository organizes code into the following clusters (observed):
-  - UI / Streamlit: Home.py, pages/, app.py, explorer.py
-  - Database & persistence: database.py, config.py
-  - ETL / pipeline: pipeline/ (run_pipeline.py, svd_pipeline, text_pipeline, fusion)
-  - AI provider & summarization: ai_provider.py, pipeline/..., analysis/
-  - Similarity & caching: similarity/*, similarity_cache table in DB
-  - API client & scraping: api_client.py, pipeline/fetch_mp_metadata
-  - Analysis & visualization: analysis/visualize.py, explorer.py
-  - CLI & scheduler: scheduler.py, pipeline/run_pipeline.py
-  - Tests & migrations: tests/ (pytest) and database reset helpers
-
-## Examples
-
-### Pipeline orchestrator (cluster: CLI & pipeline)
-```python
-from database import MotionDatabase
-db = MotionDatabase(db_path)
-# then phases: fetch_mp_metadata, extract_mp_votes, compute svd, ensure_text_embeddings, fuse_for_window
-```
-
-## Remediations
-- Add a brief CONTRIBUTING.md describing where to add new pipeline stages and how to run tests locally. Include notes about optional duckdb dependency and JSON fallback for tests.
-
-## Evidence pointers
-- pipeline/run_pipeline.py: orchestrator and cluster boundaries (file: pipeline/run_pipeline.py)
-- ai_provider.py: AI adapter for embeddings and chat (file: ai_provider.py)
-- analysis/visualize.py: visualization cluster (file: analysis/visualize.py)

.mindmodel/constraints/40-patterns.yaml

@@ -1,46 +0,0 @@
-# Design Patterns & Code Patterns
-
-## Rules
-- Use repository-style DB wrapper: MotionDatabase encapsulates DuckDB access and schema management.
-- AI provider adapter pattern: ai_provider.py exposes get_embedding(s) and chat_completion with retry/backoff and local fallback.
-- Pipeline orchestration: run_pipeline.py uses phases, ThreadPoolExecutor for parallel SVD computation with careful DuckDB connection handling (collect results before writes).
-
-## Examples
-
-### Repository pattern (database.py MotionDatabase)
-```python
-class MotionDatabase:
-    def __init__(self, db_path: str = config.DATABASE_PATH):
-        self.db_path = db_path
-        self._init_database()
-
-    def insert_motion(self, motion_data: Dict) -> bool:
-        """Insert a new motion into database"""
-        # uses duckdb.connect and parameterized queries
-```
-
-### Provider adapter with retries (ai_provider.py)
-```python
-def _post_with_retries(path: str, json: dict[str, Any], retries: int = 3) -> requests.Response:
-    # Implements retries/backoff, handles 429 with Retry-After and 5xx responses
-```
-
-### Pipeline parallelism pattern (run_pipeline)
-```python
-with ThreadPoolExecutor(max_workers=max_workers) as pool:
-    for window_id, w_start, w_end in windows:
-        fut = pool.submit(compute_svd_for_window, db.db_path, window_id, w_start, w_end, args.svd_k)
-        futures[fut] = window_id
-# wait then write sequentially to DuckDB
-```
-
-## Anti-patterns
-- Broad excepts used in several places (database.py top-level try/except on duckdb import, many generic excepts around DB operations) — can hide real errors.
-
-## Remediations
-- Replace broad except Exception with targeted exceptions and explicit logging. Where fallback is intended (e.g., optional duckdb), log at INFO/DEBUG with clear message and include guidance in CONTRIBUTING.md.
-
-## Evidence pointers
-- ai_provider.py: _post_with_retries, get_embedding(s), _local_embedding (file: ai_provider.py lines ~1-300)
-- pipeline/run_pipeline.py: ThreadPoolExecutor usage and duckdb connection handling (file: pipeline/run_pipeline.py lines ~120-260)
-- database.py: MotionDatabase methods (file: database.py)

.mindmodel/constraints/50-anti-patterns.yaml

@@ -1,24 +0,0 @@
-# Anti-patterns, Issues and Recommended Fixes
-
-## Rules
-- Flagged issues discovered in Phase 1 must be remediated with concrete actions.
-
-## Issues
-- pytest is listed as a runtime dependency (pyproject.toml). This increases image size and may pull dev-only transitive deps into production. Evidence: pyproject.toml
-- openai is declared but static imports not found; may be unused. Evidence: pyproject.toml, ai_provider.py uses requests and env keys instead of openai imports.
-- Many dependencies use permissive ">=" version ranges; no lockfile present. This reduces reproducibility.
-- Missing formatting/linting configs (black, ruff, isort, mypy). Recommended to add config and CI steps.
-- Broad except Exception used in many places (database.py, ai_provider.py fallback logic, analysis/visualize.py). This can mask bugs and slow debugging.
-
-## Remediations / Recommended fixes
-- Move pytest from runtime dependencies to dev-dependencies in pyproject.toml.
-  - Suggested patch: under [project.optional-dependencies] or [tool.poetry.dev-dependencies] depending on toolchain.
-- Audit `openai` usage. If unused, remove from pyproject.toml. If dynamically imported in runtime, add a small shim or explicit lazy import with documented env var.
-- Pin critical dependencies or add upper bounds; generate lockfile (poetry.lock or pip-tools requirements.txt). Add CI job that fails on permissive ranges.
-- Add black/ruff/isort/mypy config blocks to pyproject.toml and enable pre-commit hooks. Add CI lint stage.
-- Replace broad except Exception with narrower catches and re-raise or log with traceback when unexpected. Example locations: database.py top import, insert_motion broad except, ai_provider fallback blocks.
-
-## Evidence pointers
-- pyproject.toml: dependencies list (file: pyproject.toml lines 1-40)
-- database.py: multiple broad except blocks (file: database.py top and methods)
-- ai_provider.py: uses requests + env keys (file: ai_provider.py)

.mindmodel/constraints/60-examples.yaml

@@ -1,117 +0,0 @@
-# Example Extractions
-
-## Rules
-- Include concrete examples extracted from the codebase: function signatures with docstrings, SQL DDL snippets, and pytest stubs following repository conventions.
-
-## (a) Function signatures with docstrings (5 examples)
-1) pipeline/run_pipeline.py::_generate_windows
-```python
-def _generate_windows(start: date, end: date, granularity: str) -> List[Tuple[str, str, str]]:
-    """Return list of (window_id, start_str, end_str) tuples.
-
-    window_id format:
-      quarterly → "2024-Q1", "2024-Q2", …
-      annual    → "2024"
-    """
-```
-
-2) database.py::append_audit_event
-```python
-def append_audit_event(
-    self,
-    actor_id: Optional[str],
-    action: str,
-    target_type: Optional[str] = None,
-    target_id: Optional[str] = None,
-    metadata: Optional[Dict] = None,
-) -> bool:
-    """Record an audit event. Tries DB then falls back to ledger file."""
-```
-
-3) ai_provider.py::get_embedding
-```python
-def get_embedding(text: str, model: str | None = None) -> list[float]:
-    """Return an embedding vector for `text` using the configured provider.
-
-    Raises ProviderError for configuration or provider-side failures.
-    """
-```
-
-4) ai_provider.py::get_embeddings_batch
-```python
-def get_embeddings_batch(
-    texts: list[str], model: str | None = None, batch_size: int = 50
-) -> list[list[float]]:
-    """Return embedding vectors for multiple texts using batched API calls."""
-```
-
-5) analysis/visualize.py::plot_umap_scatter
-```python
-def plot_umap_scatter(
-    motion_ids: List[int],
-    coords: List[List[float]],
-    labels: Optional[List[int]] = None,
-    window_id: Optional[str] = None,
-    output_path: str = "analysis_umap.html",
-) -> str:
-    """Produce a 2D scatter plot of UMAP-reduced fused embeddings."""
-```
-
-## (b) SQL / DDL snippets (3 examples inferred from database.py)
-1) motions table (see constraints/10-db-schema.yaml) — evidence: database.py CREATE TABLE motions (lines ~40-110)
-
-2) mp_votes table (see constraints/10-db-schema.yaml) — evidence: database.py CREATE TABLE mp_votes
-
-3) fused_embeddings table (see constraints/10-db-schema.yaml) — evidence: database.py CREATE TABLE fused_embeddings
-
-## (c) Pytest stubs (4 sample tests matching conventions)
-Create tests under tests/ named test_*.py using fixtures in conftest.py. Examples below are stubs to add.
-
-1) tests/test_database_basic.py
-```python
-def test_init_database_creates_tables(tmp_path):
-    db_path = str(tmp_path / "motions.db")
-    from database import MotionDatabase
-
-    db = MotionDatabase(db_path=db_path)
-    # If duckdb not available, JSON fallback should create .embeddings.json
-    assert db is not None
-```
-
-2) tests/test_ai_provider.py
-```python
-def test_local_embedding_fallback():
-    from ai_provider import _local_embedding
-
-    v = _local_embedding("hello world", dim=16)
-    assert isinstance(v, list) and len(v) == 16
-```
-
-3) tests/test_pipeline_windows.py
-```python
-from pipeline.run_pipeline import _generate_windows
-
-def test_generate_quarterly_windows():
-    from datetime import date
-
-    start = date(2024, 1, 1)
-    end = date(2024, 3, 31)
-    windows = _generate_windows(start, end, "quarterly")
-    assert any(w[0].endswith("Q1") for w in windows)
-```
-
-4) tests/test_visualize_plot.py
-```python
-def test_plot_umap_scatter_no_plotly(monkeypatch, tmp_path):
-    # If plotly missing, function should raise ImportError with guidance
-    import analysis.visualize as vis
-
-    try:
-        vis._require_plotly()
-    except ImportError:
-        assert True
-```
-
-## Evidence pointers
-- Function docstrings: pipeline/run_pipeline.py, ai_provider.py, analysis/visualize.py, database.py
-- DDL: database.py create table blocks

.mindmodel/constraints/99-stack.yaml

@@ -1,43 +0,0 @@
-# Stack and Dependencies
-
-## Rules
-- Primary language: Python >=3.13 (evidence: pyproject.toml requires-python = ">=3.13")
-- Application: Streamlit app (streamlit >=1.48.0). Entrypoint: Home.py (CMD: streamlit run Home.py). Evidence: Home.py, pages/1_Stemwijzer.py, pyproject.toml, Dockerfile
-- Database: DuckDB + Ibis (duckdb>=1.3.2, ibis-framework[duckdb]>=10.8.0). Evidence: pyproject.toml, database.py
-- ML: scikit-learn, umap-learn, scipy. Evidence: pyproject.toml, pipeline/svd.py, analysis/
-
-## Examples
-
-### pyproject dependencies (evidence: pyproject.toml)
-```toml
-dependencies = [
-    "duckdb>=1.3.2",
-    "ibis-framework[duckdb]>=10.8.0",
-    "openai>=1.99.7",
-    "scipy>=1.11",
-    "umap-learn>=0.5",
-    "plotly>=5.0",
-    "pytest>=9.0.2",
-    "requests>=2.32.4",
-    "schedule>=1.2.2",
-    "streamlit>=1.48.0",
-    "scikit-learn>=1.8.0",
-    "beautifulsoup4>=4.14.3",
-    "lxml>=6.0.2",
-]
-```
-
-## Anti-patterns / Notes
-- pytest is listed under runtime dependencies in pyproject.toml (line: dependencies). Move pytest to dev-dependencies to avoid shipping test runner in production images. Evidence: pyproject.toml
-- Many dependencies use permissive ">=" ranges. Recommend pinning or generating lockfile (poetry.lock/requirements.txt) and adding upper bounds for reproducibility.
-- openai appears declared but static imports not found; possible unused dependency (evidence: pyproject.toml, ai_provider.py uses requests and environment keys instead of openai).
-
-## Remediations
-- Move test-only libs (pytest) to dev-dependencies in pyproject.toml.
-- Add lockfile and CI step to check for pinned dependencies.
-- Audit declared but unused packages (openai) and remove or confirm dynamic usage.
-
-## Evidence pointers
-- pyproject.toml: full dependency list (lines 1-40)
-- Home.py: streamlit usage and app entry (file: Home.py) 
-- database.py: duckdb table creation and connection (file: database.py lines ~1-350)

.mindmodel/constraints/README.md

@@ -1,5 +0,0 @@
-# Mindmodel constraints README
-
-Files in .mindmodel/constraints/ are YAML-like constraint documents describing
-conventions, patterns and remediation steps. Use these to guide PR reviews and
-CI automation.

.mindmodel/constraints/db_connection.yaml

@@ -1,29 +0,0 @@
-# DB connection handling constraints
-
-rules:
-  - name: use_context_managers_for_connections
-    rule: "Prefer using 'with duckdb.connect(path, read_only=...) as conn' for scoped DB interactions where possible."
-    rationale: "Ensures proper resource cleanup and avoids connection leaks."
-
-  - name: read_only_for_compute
-    rule: "Use read_only=True for compute steps that only read data (SVD, similarity compute)."
-    rationale: "Allows safe parallel workers and reduces write contention."
-
-  - name: short_lived_writes
-    rule: "When performing database writes, open short-lived connections, commit quickly and close."
-    rationale: "Avoids long-lived transactions and reduces lock windows."
-
-examples:
-  - path: pipeline/svd_pipeline.py
-    snippet: |
-      conn = duckdb.connect(db_path, read_only=True)
-      try:
-          rows = conn.execute(...).fetchall()
-      finally:
-          conn.close()
-
-anti_patterns_and_remediations:
-  - bad: "Creating a global connection at import that performs migrations."
-    remediation: "Move migrations to an explicit init function that runs at deployment/upgrade time."
-  - bad: "Not closing connections on exceptions."
-    remediation: "Wrap connects in `with` or finally: conn.close() blocks."

.mindmodel/constraints/error_handling.yaml

@@ -1,36 +0,0 @@
-# Error handling style rules (YAML constraint example)
-
-rules:
-  - name: explicit_exceptions
-    rule: "Raise explicit exceptions (ValueError, ProviderError) for known error conditions rather than returning magic values."
-    examples:
-      - good: |
-          if not isinstance(text, str):
-              raise ProviderError('text must be a string')
-      - bad: |
-          if not isinstance(text, str):
-              return []
-
-  - name: avoid_broad_except
-    rule: "Avoid 'except Exception:' that swallows errors. If broad except is used for best-effort, log the exception with logger.exception and re-raise or convert."
-    examples:
-      - bad: |
-          try:
-              do_work()
-          except Exception:
-              return []
-      - remediation: |
-          try:
-              do_work()
-          except SpecificError as exc:
-              logger.warning('Handled error: %s', exc)
-              raise
-
-  - name: logging_over_print
-    rule: "Prefer logger.* over print() for messages and errors."
-    examples:
-      - bad: "print('Error fetching motions from API: %s' % e)"
-      - good: "logger.exception('Error fetching motions from API')"
-
-enforcement_examples:
-  - "Add a static code check to flag 'print(' in modules (except in simple scripts) and 'except Exception:' usages without logger.exception."

.mindmodel/constraints/imports.yaml

@@ -1,24 +0,0 @@
-# Import grouping and ordering constraints
-
-rules:
-  - name: grouping
-    rule: "Group imports in three sections separated by a single blank line: stdlib, third-party, local."
-    examples:
-      - good: |
-          import json
-          import logging
-
-          import requests
-          import duckdb
-
-          from .pipeline import text_pipeline
-      - bad: |
-          import duckdb
-          import json
-          from pipeline import text_pipeline
-
-  - name: from_imports
-    rule: "Prefer 'from x import y' only when it improves clarity or avoids circular import; otherwise import module and reference attributes."
-
-enforcement_examples:
-  - "Run isort or ruff- import sorting in pre-commit or CI to enforce ordering."

.mindmodel/constraints/naming.yaml

@@ -1,30 +0,0 @@
-# Naming constraint rules (example constraint file)
-
-rules:
-  - name: module_file_names
-    rule: "Use snake_case for Python module filenames (e.g., text_pipeline.py, ai_provider.py)."
-    examples:
-      - good: "text_pipeline.py"
-      - bad: "TextPipeline.py"
-
-  - name: function_names
-    rule: "Use snake_case for functions and methods."
-    examples:
-      - good: "def compute_similarities(...):"
-      - bad: "def ComputeSimilarities(...):"
-
-  - name: class_names
-    rule: "Use PascalCase for classes."
-    examples:
-      - good: "class MotionDatabase:"
-      - bad: "class motion_database:"
-
-  - name: constants
-    rule: "Constants use UPPER_SNAKE_CASE."
-    examples:
-      - good: "VOTE_MAP = { ... }"
-      - bad: "vote_map = { ... }"
-
-enforcement_examples:
-  - "Add a linter rule in CI: ruff or flake8 naming plugin to detect violations."
-  - "Run `python -m pip install ruff` and `ruff check` as part of CI."

.mindmodel/constraints/testing.yaml

@@ -1,26 +0,0 @@
-# Testing conventions constraint (YAML)
-
-rules:
-  - name: test_naming
-    rule: "Use pytest and name tests test_*.py and test_* functions."
-    examples:
-      - good: "tests/test_text_pipeline.py"
-      - bad: "tests/text_pipeline_test.py"
-
-  - name: fixtures_and_conftest
-    rule: "Place shared fixtures in tests/conftest.py or tests/fixtures/ for reuse."
-    examples:
-      - good: "use fixtures declared in tests/conftest.py"
-
-  - name: assert_raises
-    rule: "Explicitly assert expected exceptions with pytest.raises for invalid input."
-    examples:
-      - good: |
-          import pytest
-
-          def test_invalid_input():
-              with pytest.raises(ValueError):
-                  function_under_test('bad')
-
-enforcement_examples:
-  - "Run pytest in CI; fail if tests don't run or if there are regressions."

.mindmodel/conventions.yaml

@@ -1,32 +0,0 @@
-# Coding conventions cheat-sheet (extracted from Phase 1)
-
-naming:
-  module_files: snake_case (e.g., text_pipeline.py, ai_provider.py)
-  functions: snake_case
-  classes: PascalCase
-  constants: UPPER_SNAKE_CASE
-  module_singletons: module-level instances, named lower_snake (e.g., db = MotionDatabase())
-
-imports:
-  order:
-    - stdlib
-    - third-party
-    - local application imports
-  style:
-    - group imports with a blank line between groups
-    - prefer "from x import y" only when needed to avoid circular imports
-
-types_and_dataclasses:
-  - Use type hints broadly (functions, public APIs)
-  - config should be a dataclass in config.py
-  - Module-level singletons are allowed (but follow lifecycle rules in db_connection constraints)
-
-tests:
-  - pytest
-  - tests/ directory, files named test_*.py
-  - Use fixtures in tests/fixtures and conftest.py
-  - Tests expect raises(...) for invalid input or ProviderError
-
-error_handling:
-  - Prefer explicit exceptions (ValueError, ProviderError)
-  - Avoid overly-broad except: clauses (see anti-patterns)

.mindmodel/dependencies.yaml

@@ -1,55 +0,0 @@
-# Dependencies map and recommended extras (Phase 1 authoritative)
-declared:
-  - streamlit
-  - duckdb
-  - ibis-framework[duckdb]
-  - plotly
-  - scikit-learn
-  - scipy
-  - umap-learn
-  - openai  # note: declared but not observed imported; review usage
-  - requests
-
-observed:
-  - requests
-  - duckdb (used but sometimes import guarded)
-  - numpy
-  - pytest
-
-grouped:
-  core:
-    - python >=3.13
-    - streamlit
-    - duckdb
-    - ibis-framework[duckdb]
-    - requests
-  ml:
-    - scikit-learn
-    - scipy
-    - umap-learn
-    - numpy
-  viz:
-    - plotly
-  testing:
-    - pytest
-
-recommended_extras:
-  reproducibility:
-    - poetry (poetry.lock) or pip-tools (requirements.txt + requirements.in)
-    - pipx or virtualenv usage documented
-  linting_and_formatting:
-    - black
-    - ruff
-    - isort
-    - mypy
-  logging_and_monitoring:
-    - structlog (optional)
-  containerization:
-    - docker (already used)
-  heavy_analytics (optional):
-    - pandas
-    - altair
-    - dash (if more interactive dashboards are needed)
-notes:
-  - Because no lockfile was present during Phase 1, adding one is high priority for reproducible CI builds.
-  - openai is declared but not imported anywhere in Phase 1 files; prefer to either remove or add an explicit adapter usage and tests.

.mindmodel/domain-glossary.yaml

@@ -1,37 +0,0 @@
-# Domain glossary (core concepts from Phase 1)
-
-terms:
-  Motion:
-    short: "A parliamentary motion/decision"
-    keys: [id, title, description, date, body_text, url]
-  motie:
-    short: "Dutch: motion (motie). Equivalent to Motion in code comments and UI."
-  MP:
-    short: "Member of Parliament (kamerlid)"
-    keys: [mp_name, party, van, tot_en_met, persoon_id]
-  mp_votes:
-    short: "Raw voting rows: motion_id, mp_name, vote, date"
-  mp_metadata:
-    short: "Per-MP metadata table and fields"
-  user_sessions:
-    short: "Streamlit user quiz session state (session_id, user_votes, completed_motions...)"
-  embeddings:
-    short: "Raw text embeddings stored per motion (embeddings table)"
-  svd_vectors:
-    short: "SVD-derived vectors from the vote matrix (svd_vectors table)"
-  fused_embeddings:
-    short: "Concatenation of SVD and text embeddings (fused_embeddings table)"
-  similarity_cache:
-    short: "Precomputed nearest neighbors for each motion"
-  window_id:
-    short: "Processing window identifier used for SVD/fusion runs"
-  controversy_score:
-    short: "Numeric measure stored in motions table"
-  winning_margin:
-    short: "Numeric field indicating margin of win in a vote"
-  Politiek_Kompas:
-    short: "Political compass; also appears in UI features"
-  MP_quiz:
-    short: "Interactive quiz derived from motions and mp_votes"
-notes:
-  - Use these canonical terms in docs, tests, variable names and DB schemas.

.mindmodel/examples/pattern-examples.md

@@ -1,116 +0,0 @@
-# Extracted pattern examples (representative snippets)
-
-Note: snippets are verbatim extracts from repository files (Phase 1). Paths shown.
-
-## DuckDB connect + schema init (database.py)
-```python
-conn = duckdb.connect(self.db_path)
-
-# Create sequence for auto-incrementing IDs
-try:
-    conn.execute("CREATE SEQUENCE IF NOT EXISTS motions_id_seq START 1")
-except:
-    pass
-
-# Create tables with proper ID handling
-conn.execute("""
-    CREATE TABLE IF NOT EXISTS motions (
-        id INTEGER DEFAULT nextval('motions_id_seq'),
-        title TEXT NOT NULL,
-        description TEXT,
-        date DATE,
-        policy_area TEXT,
-        voting_results JSON,
-        winning_margin FLOAT,
-        controversy_score FLOAT,
-        layman_explanation TEXT,
-        externe_identifier TEXT,
-        body_text TEXT,
-        url TEXT UNIQUE,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY (id)
-    )
-""")
-conn.close()
-```
-
-## Read-only compute worker (svd_pipeline.py)
-```python
-conn = duckdb.connect(db_path, read_only=True)
-try:
-    rows = conn.execute(
-        "SELECT motion_id, mp_name, vote FROM mp_votes WHERE date BETWEEN ? AND ?",
-        (start_date, end_date),
-    ).fetchall()
-finally:
-    conn.close()
-```
-
-## Requests with retry/backoff (ai_provider.py)
-```python
-resp = requests.post(url, json=json, headers=headers, timeout=10)
-...
-if getattr(resp, "status_code", 0) == 429:
-    if attempt == retries:
-        raise ProviderError(f"Provider returned HTTP {resp.status_code}")
-    retry_after = None
-    raw = resp.headers.get("Retry-After") if getattr(resp, "headers", None) else None
-    if raw:
-        try:
-            retry_after = int(raw)
-        except Exception:
-            try:
-                dt = parsedate_to_datetime(raw)
-                now = datetime.now(tz=dt.tzinfo or timezone.utc)
-                secs = (dt - now).total_seconds()
-                retry_after = max(0, int(secs))
-            except Exception:
-                retry_after = None
-
-    if retry_after is not None:
-        time.sleep(retry_after)
-        continue
-```
-
-## Embedding batch + per-item fallback (pipeline/ai_provider_wrapper.py)
-```python
-for start in range(0, len(texts), batch_size):
-    chunk = texts[i:end]
-    emb_chunk, emb_exc = _attempt_batch(chunk, i)
-    if emb_chunk is not None:
-        for j, emb in enumerate(emb_chunk):
-            results[i + j] = emb
-        i = end
-        continue
-
-    # batch failed -> fallback to per-item attempts
-    for j in range(i, end):
-        t = texts[j]
-        single, single_exc = _attempt_batch([t], j)
-        if single:
-            results[j] = single[0]
-            continue
-        results[j] = None
-```
-
-## Similarity compute (similarity/compute.py)
-```python
-# Ensure consistent dimensionality: pad shorter vectors with zeros
-lengths = [len(v) for v in vecs]
-max_dim = max(lengths)
-if len(set(lengths)) != 1:
-    logger.warning(
-        "Inconsistent vector dimensions detected (max=%d). Padding shorter vectors with zeros.",
-        max_dim,
-    )
-
-matrix = np.zeros((len(vecs), max_dim), dtype=np.float32)
-for i, v in enumerate(vecs):
-    matrix[i, : len(v)] = v
-
-# Normalize rows and compute cosine similarity
-norms = np.linalg.norm(matrix, axis=1, keepdims=True)
-norms[norms == 0] = 1.0
-normalized = matrix / norms
-sim = normalized @ normalized.T
-```

.mindmodel/manifest.yaml

@@ -1,15 +0,0 @@
-# DO NOT EDIT - read-only until validated
-# Sanitized manifest: contains non-sensitive sample excerpts only
-files:
-  - path: src/lib/schema.ts
-    evidence_excerpt: "Defines schema for user input validation"
-    flags:
-      needs_review: true
-  - path: src/api/handler.ts
-    evidence_excerpt: "Handles API requests and routing"
-    flags:
-      needs_review: false
-  - path: README.md
-    evidence_excerpt: "Project overview and setup instructions"
-    flags:
-      needs_review: true

.mindmodel/patterns/duckdb_access.yaml

@@ -1,70 +0,0 @@
-name: duckdb_access
-
-rules:
-  - Prefer using read_only=True for compute-only subprocesses (e.g., SVD compute) to allow concurrent readers.
-  - Prefer "with duckdb.connect(db_path, read_only=True) as conn" for scoped connections so conn.close() is automatic.
-  - If a long-lived connection is created at module level, provide explicit close() or ensure operation is safe for Streamlit's lifecycle.
-  - Prefer parameterizing db_path in pipelines and creating connections locally (avoid global connections that cross threads).
-
-examples:
-  - path: database.py
-    excerpt: |
-      ```python
-      conn = duckdb.connect(self.db_path)
-      ...
-      conn.execute("""
-          CREATE TABLE IF NOT EXISTS fused_embeddings (
-              id INTEGER DEFAULT nextval('fused_embeddings_id_seq'),
-              motion_id INTEGER NOT NULL,
-              window_id TEXT NOT NULL,
-              vector JSON NOT NULL,
-              svd_dims INTEGER NOT NULL,
-              text_dims INTEGER NOT NULL,
-              created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-              PRIMARY KEY (id)
-          )
-      """)
-      conn.close()
-      ```
-    note: explicit connect/close used when initializing schema
-
-  - path: pipeline/svd_pipeline.py
-    excerpt: |
-      ```python
-      conn = duckdb.connect(db_path, read_only=True)
-      try:
-          rows = conn.execute(
-              "SELECT motion_id, mp_name, vote FROM mp_votes WHERE date BETWEEN ? AND ?",
-              (start_date, end_date),
-          ).fetchall()
-      finally:
-          conn.close()
-      ```
-    note: read_only connection used for compute-heavy worker
-
-  - path: similarity/compute.py
-    excerpt: |
-      ```python
-      try:
-          import duckdb
-      except Exception:
-          logger.exception("duckdb import failed; cannot load vectors")
-          return 0
-
-      with duckdb.connect(db.db_path) as conn:
-          rows = conn.execute(query, params).fetchall()
-      ```
-    note: preferred 'with' context for automatic close
-
-anti_patterns:
-  - Bad: creating a connection without closure in a long-running process
-    remediation: use "with" context or ensure conn.close() in finally block
-    example: |
-      ```python
-      # BAD: connection may leak if exception occurs before explicit close
-      conn = duckdb.connect(db_path)
-      rows = conn.execute("SELECT ...").fetchall()
-      # missing finally/close
-      ```
-  - Bad: Opening write connections from many parallel workers without coordination
-    remediation: open read_only for compute processes and centralize writes via short-lived connections or a single writer worker.

.mindmodel/patterns/embeddings_similarity.yaml

@@ -1,63 +0,0 @@
-name: embeddings_similarity_pipeline
-
-rules:
-  - Keep embedding calls batched where possible; fallback to per-item attempts on persistent batch failure.
-  - Store raw embeddings, SVD vectors, and fused_embeddings separately; fused_embeddings are typically concatenation [svd + text].
-  - Compute similarity as normalized cosine on padded vectors; record top-k neighbors in similarity_cache.
-  - Use read_only DuckDB connections in compute workers to allow parallel runs.
-
-examples:
-  - path: pipeline/ai_provider_wrapper.py
-    excerpt: |
-      ```python
-      for start in range(0, len(texts), batch_size):
-          chunk = texts[start : start + batch_size]
-          resp = _post_with_retries("/embeddings", json={"model": model, "input": chunk})
-      ...
-      for j in range(i, end):
-          t = texts[j]
-          single, single_exc = _attempt_batch([t], j)
-          if single:
-              results[j] = single[0]
-      ```
-    note: batched embed + fallback per-item retry
-
-  - path: pipeline/fusion.py
-    excerpt: |
-      ```python
-      try:
-          svd_vec = json.loads(svd_json)
-      except Exception:
-          _logger.exception("Invalid SVD vector JSON for entity %s", entity_id)
-          skipped_missing_svd += 1
-          continue
-      ...
-      fused = list(svd_vec) + list(text_vec)
-      res = db.store_fused_embedding(
-          int(entity_id),
-          window_id,
-          fused,
-          svd_dims=len(svd_vec),
-          text_dims=len(text_vec),
-      )
-      ```
-    note: concatenation of vectors and storage via MotionDatabase
-
-  - path: similarity/compute.py
-    excerpt: |
-      ```python
-      # Normalize rows
-      norms = np.linalg.norm(matrix, axis=1, keepdims=True)
-      norms[norms == 0] = 1.0
-      normalized = matrix / norms
-      sim = normalized @ normalized.T
-      ...
-      # pick top-k neighbors and write to similarity_cache
-      ```
-    note: numeric pipeline and padding to consistent dimensionality
-
-anti_patterns:
-  - Bad: Assuming consistent vector length without checks (leads to shape errors).
-    remediation: Detect inconsistent lengths, pad with zeros, and log a warning (as seen in compute.py).
-  - Bad: Recomputing heavy pipelines inline in UI requests.
-    remediation: schedule heavy work in scripts/subprocesses and read precomputed results in UI.

.mindmodel/patterns/error_handling.yaml

@@ -1,54 +0,0 @@
-name: error_handling
-
-rules:
-  - Use explicit exceptions for domain/error classification (e.g., ProviderError, ValueError).
-  - Prefer logging.exception when catching an exception where stack trace is useful.
-  - Avoid broad except: clauses that swallow exceptions; if broad except is used for "best-effort" fallback, log at warning and include original exception context.
-  - For public library-like functions, prefer raising typed exceptions instead of returning magic values ([], False) — only return safe defaults where documented.
-
-examples:
-  - path: ai_provider.py
-    excerpt: |
-      ```python
-      except requests.ConnectionError as exc:
-          if attempt == retries:
-              raise ProviderError(
-                  f"Connection error when calling provider: {exc}"
-              ) from exc
-          ...
-      ```
-    note: mapping network error to ProviderError with re-raise chaining
-
-  - path: pipeline/ai_provider_wrapper.py
-    excerpt: |
-      ```python
-      except Exception:
-          _logger.exception("Failed to append audit event for embedding failure")
-      results[j] = None
-      ```
-    note: logs and assigns None for failure; fallback behavior documented earlier in wrapper rule
-
-  - path: similarity/compute.py
-    excerpt: |
-      ```python
-      try:
-          import duckdb
-      except Exception:
-          logger.exception("duckdb import failed; cannot load vectors")
-          return 0
-      ```
-    note: defensive import handling and early return on failure
-
-anti_patterns:
-  - Bad: Broad except without logging and without re-raising (silently hides bugs)
-    remediation: Narrow exception types or at minimum log.exception() and re-raise or convert to a domain error if truly handled.
-    example: |
-      ```python
-      try:
-          do_work()
-      except Exception:
-          return []
-      # BAD: hides the root cause and returns an ambiguous default
-      ```
-  - Bad: Mixing print() and logging for errors
-    remediation: Replace print() calls with logger.* calls; use structured logging configuration.

.mindmodel/patterns/module_singletons.yaml

@@ -1,33 +0,0 @@
-name: module_singletons
-
-rules:
-  - Module-level singletons (e.g., db = MotionDatabase()) are acceptable but should be created carefully:
-    - Avoid expensive initialization at import time.
-    - Provide a way to construct with a test DB path or to reinitialize in tests.
-  - If a singleton holds resources (DB connections, sessions), ensure safe shutdown on program exit.
-
-examples:
-  - path: database.py
-    excerpt: |
-      ```python
-      class MotionDatabase:
-          def __init__(self, db_path: str = config.DATABASE_PATH):
-              self.db_path = db_path
-              # If duckdb is not available, operate in lightweight file-backed mode
-              self._file_mode = duckdb is None
-              self._init_database()
-      ```
-    note: class is safe to instantiate and creates DB at init; consider lazy init if heavy
-
-  - path: similarity/lookup.py
-    excerpt: |
-      ```python
-      db = MotionDatabase(db_path=db_path) if db_path else MotionDatabase()
-      if hasattr(db, "get_cached_similarities"):
-          rows = db.get_cached_similarities(...)
-      ```
-    note: consumers create local MotionDatabase instances, not relying on a single global
-
-anti_patterns:
-  - Bad: Creating connections and performing heavy schema migrations during import
-    remediation: Move heavy init to an explicit initialize() method and keep import fast.

.mindmodel/patterns/requests_http.yaml

@@ -1,65 +0,0 @@
-name: requests_http
-
-rules:
-  - Reuse requests.Session when making multiple calls to the same host to benefit from connection pooling.
-  - Wrap outbound HTTP calls with retry/backoff logic and respect Retry-After on 429.
-  - Treat 5xx as transient and retry; surface 4xx as configuration/client errors (do not retry unless 429).
-  - Raise or wrap non-OK responses into domain ProviderError to make behavior consistent across the codebase.
-
-examples:
-  - path: ai_provider.py
-    excerpt: |
-      ```python
-      resp = requests.post(url, json=json, headers=headers, timeout=10)
-      ...
-      if getattr(resp, "status_code", 0) == 429:
-          if attempt == retries:
-              raise ProviderError(f"Provider returned HTTP {resp.status_code}")
-          retry_after = None
-          raw = resp.headers.get("Retry-After") if getattr(resp, "headers", None) else None
-          if raw:
-              try:
-                  retry_after = int(raw)
-              except Exception:
-                  ...
-          if retry_after is not None:
-              time.sleep(retry_after)
-              continue
-      ```
-    note: explicit handling of 429 and Retry-After
-
-  - path: api_client.py
-    excerpt: |
-      ```python
-      response = self.session.get(
-          base_url, params=params, timeout=config.API_TIMEOUT
-      )
-      response.raise_for_status()
-      data = response.json()
-      ```
-    note: uses session + raise_for_status() to surface HTTP errors
-
-  - path: pipeline/ai_provider_wrapper.py
-    excerpt: |
-      ```python
-      def _attempt_batch(chunk_texts, start_index):
-          backoff = 0.5
-          for attempt in range(1, retries + 1):
-              try:
-                  emb_chunk = _embedder(
-                      chunk_texts, model=model, batch_size=len(chunk_texts)
-                  )
-                  return emb_chunk, None
-              except Exception as exc:
-                  if attempt == retries:
-                      break
-                  sleep = backoff * (2 ** (attempt - 1))
-                  time.sleep(sleep)
-                  continue
-      ```
-    note: wrapper adds retry/backoff and per-item fallback
-
-anti_patterns:
-  - Bad: Blindly catching all requests exceptions and returning empty response
-    remediation: map network exceptions to retryable vs terminal (ProviderError) and log details.
-  - Bad: Using print() for network errors instead of structured logging (see api_client.py where print() is used; prefer logging).

.mindmodel/patterns/validation.yaml

@@ -1,29 +0,0 @@
-name: validation
-
-rules:
-  - Validate inputs early and raise ValueError or domain-specific exceptions (ProviderError) for invalid contract inputs.
-  - Tests should assert that invalid inputs raise the expected exceptions.
-  - Use explicit checks for types and shapes on public APIs (e.g., ensure text is str before embedding).
-
-examples:
-  - path: ai_provider.py
-    excerpt: |
-      ```python
-      if not isinstance(text, str):
-          raise ProviderError("text must be a string")
-      ```
-    note: explicit type validation before network call
-
-  - path: pipeline/ai_provider_wrapper.py
-    excerpt: |
-      ```python
-      if not texts:
-          return []
-      if motion_ids is None:
-          motion_ids = [None for _ in texts]
-      ```
-    note: defensive handling of empty inputs
-
-anti_patterns:
-  - Bad: Allowing invalid values to propagate into heavy computation (e.g., non-string into embedding pipeline).
-    remediation: Fail fast with a typed exception and add unit tests to cover validations.

.mindmodel/stack.yaml

@@ -1,33 +0,0 @@
-# Tech stack (Phase 1 authoritative)
-
-language:
-  name: python
-  version: ">=3.13"
-
-frameworks:
-  - streamlit: ">=1.48.0"  # UI: Home.py, pages/..., app.py
-
-database:
-  primary: duckdb
-  orm_or_adapter: ibis-framework[duckdb]  # used for some parts
-
-visualization:
-  - plotly
-
-ml:
-  - scikit-learn
-  - scipy
-  - umap-learn
-
-ai:
-  declared_dependency: openai  # declared in pyproject but not observed imported; ai_provider uses requests
-  runtime_adapter: custom requests-based wrapper (ai_provider.py)
-
-container:
-  - docker: Dockerfile FROM python:3.13-slim, EXPOSE 8501, CMD streamlit run Home.py
-
-testing:
-  - pytest
-
-ci:
-  - drone: .drone.yml present

.mindmodel/system.md

@@ -1,14 +0,0 @@
-# System Overview: Stemwijzer
-
-This mindmodel documents constraints, conventions and patterns for the Stemwijzer
-project (Python Streamlit app with DuckDB-backed pipeline for parliamentary
-motions embedding analysis).
-
-Key points:
-- Language: Python >=3.13
-- UI: Streamlit multi-page app (Home.py, pages/)
-- Storage: DuckDB with JSON fallback for tests/dev (database.py)
-- Pipeline: ETL and SVD/text fusion pipeline (pipeline/run_pipeline.py)
-- AI: ai_provider adapter uses HTTP-based OpenRouter/OpenAI-compatible API with retry/backoff and local fallback. QWEN via OpenRouter is the recommended path; prefer OPENROUTER_API_KEY with OPENAI_API_KEY as a fallback where applicable.
-
-Use the .mindmodel/ constraints files to guide code changes, CI, and onboarding.

.opencode/skills/score-extremity/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: score-extremity
+description: Two-dimensional extremity scoring for Dutch parliamentary motions. Use when scoring policy radicalism along stylistic vs material impact dimensions, or when performing LLM-based analysis of motion text extremity.
+---
+
+# Two-Dimensional Extremity Scoring
+
+Score Dutch parliamentary motions on TWO independent dimensions:
+
+1. **Stijl-extremiteit (stylistic extremity, 1–5):** How inflammatory, harsh, or rhetorically charged is the language? 1 = neutral/technical, 5 = openly hostile/discriminatory language.
+
+2. **Materiele impact (material impact, 1–5):** How fundamentally would this policy change the status quo if enacted? How many people are affected and how deeply? Score based on the scale and permanence of the change, regardless of political direction. 1 = procedural/ministerial request, 5 = fundamental restructuring of rights, institutions, or economic systems.
+
+These dimensions are independent. A motion can be:
+- High stylistic, low material: "Alle buitenlanders moeten het land uit!" (inflammatory but legally vacuous)
+- Low stylistic, high material: "De zorgpremie wordt inkomensafhankelijk en de bijdrage loopt op tot 15% van het inkomen" (measured language but fundamentally restructures healthcare funding)
+- Low stylistic, high material (restriction): "Het recht op gezinshereniging wordt beperkt tot kerngezin met inkomenseis van 150% minimumloon" (measured language but concretely restricts rights)
+- High stylistic, high material: "Nederland stapt per direct uit de Europese Unie" (inflammatory AND structurally transformative)
+
+## Scoring Prompt
+
+```text
+Beoordeel de volgende motie op TWEE onafhankelijke dimensies:
+
+MOTIE:
+Titel: {title}
+Tekst: {text}
+Vereenvoudigde uitleg: {layman}
+
+1) STIJL-EXTREMITEIT (1-5):
+Hoe fel/opruiend/geladen is het taalgebruik? Let op woordkeuze, toon, en retorische middelen.
+1 = neutraal/technisch/ambtelijk, 3 = stellige politieke taal/waardeoordelen, 5 = vijandig/discriminerend/haatdragend taalgebruik.
+
+2) MATERIELE IMPACT (1-5):
+Hoe fundamenteel verandert dit voorstel de status quo? Hoeveel mensen worden geraakt en hoe diep?
+Scoor op basis van de schaal en duurzaamheid van de verandering, ongeacht politieke richting.
+Linkse én rechtse moties kunnen hoge impact hebben — het gaat om hoe ingrijpend de verandering is.
+1 = procedureel/symbolisch/onderzoeksverzoek, 3 = concrete beleidswijziging met meetbare gevolgen voor een sector/doelgroep, 5 = fundamentele herstructurering van rechten, instituties of economische systemen met langdurige gevolgen voor de hele samenleving.
+
+Geef voor elke dimensie een score van 1-5 en een korte toelichting in het Nederlands.
+```
+
+## Output Schema
+
+Return a JSON object with this structure:
+
+```json
+{
+  "stijl_extremiteit": 3,
+  "stijl_toelichting": "Gebruikt termen als 'massa-immigratie' en 'tsunami' maar niet direct discriminerend",
+  "materiele_impact": 4,
+  "materiele_toelichting": "Beperkt recht op gezinshereniging tot kerngezin met verzwaarde inkomenseis"
+}
+```
+
+Field constraints:
+- `stijl_extremiteit`: integer, 1–5
+- `stijl_toelichting`: string, Dutch, 1–3 sentences
+- `materiele_impact`: integer, 1–5
+- `materiele_toelichting`: string, Dutch, 1–3 sentences
+
+## Batch Scoring
+
+When scoring multiple motions at once, return a JSON array:
+
+```json
+{
+  "motions": [
+    {
+      "motion_id": 123,
+      "stijl_extremiteit": 3,
+      "stijl_toelichting": "...",
+      "materiele_impact": 4,
+      "materiele_toelichting": "..."
+    }
+  ]
+}
+```
+
+## Subagent Workflow
+
+The orchestrator spawns subagents (deepseek v4 flash) to score motions in batches:
+
+1. Read this skill file to get the prompt template and schema
+2. Query the stratified sample from `right_wing_motions` JOIN `extremity_scores`
+3. Format batches of 10 motions each
+4. For each batch, spawn a subagent (`task` tool, subagent_type: general) with:
+   - This skill's prompt template filled with the 10 motions' text and layman explanations
+   - The output schema as the expected return format
+   - Instruction to return valid JSON matching the `motions` array schema
+5. Collect results, validate against schema, store in `extremity_scores_2d` table
+6. Compute Pearson r between `stijl_extremiteit` and `materiele_impact`
+
+Batch dispatch is parallel: all 10 subagents (for 100 motions) can be spawned simultaneously since they have no inter-dependencies.

.pre-commit-config.yaml

@@ -1,17 +1,18 @@
-# Minimal pre-commit config stub
-# This file is intentionally minimal and does not enable hooks by installing them.
 repos:
   - repo: https://github.com/psf/black
-    rev: 23.9.1
+    rev: 25.1.0
     hooks:
       - id: black
+        language_version: python3.13
 
-  - repo: https://github.com/charliermarsh/ruff
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
     rev: v0.11.1
     hooks:
       - id: ruff
+        args: [--fix]
 
   - repo: https://github.com/PyCQA/isort
-    rev: 5.12.0
+    rev: 6.0.1
     hooks:
       - id: isort
+        args: [--profile, black]

.streamlit/config.toml

@@ -0,0 +1,9 @@
+[theme]
+primaryColor = "#00d9a3"
+backgroundColor = "#0d1117"
+secondaryBackgroundColor = "#161b22"
+textColor = "#e6edf3"
+font = "sans serif"
+
+[ui]
+showDeployButton = false

AGENTS.md

@@ -0,0 +1,24 @@
+# Agents
+
+## Documented Solutions
+
+`docs/solutions/` — documented solutions to past problems (bugs, best practices, workflow patterns), organized by category with YAML frontmatter (`module`, `tags`, `problem_type`). Relevant when implementing or debugging in documented areas.
+
+## Infrastructure Notes
+
+- Git is hosted on a **Gitea** server, not GitHub directly. The `gh` CLI is not available for this repo; use standard `git` commands instead.
+
+## Agent Tools
+
+`agent_tools/` — atomic primitives that let an agent operate the Stemwijzer pipeline, database, and analysis surface. The agent-native architecture track (see STRATEGY.md) exposes every human operator capability through these tools.
+
+**When operating on the database, pipeline, or analysis surface, always prefer `agent_tools` over ad-hoc SQL or direct module calls.** Use `agent_tools.list_tools()` for runtime discovery. For the full agent persona and decision criteria, see `agent_tools/SYSTEM_PROMPT.md`.
+
+## Project Conventions
+
+- Right-wing parties (PVV, FVD, JA21, SGP) must appear on the RIGHT side of all axes in visualizations
+- SVD labels should reflect voting patterns, not semantic content — see `docs/solutions/best-practices/svd-labels-voting-patterns-not-semantics.md`
+- Centrist definition for Overton analysis: strict 4-party (D66, CDA, CU, NSC) — not VVD/BBB
+- Right-wing motion classification uses hybrid keywords + voting pattern approach — see `analysis/right_wing/classify_motions.py`
+- Two-dimensional extremity scoring separates stylistic (language) from material (policy impact) — see `.opencode/skills/score-extremity/SKILL.md`
+- SVD axis sign convention after Procrustes: axis 2 negative = nationalist (PVV -0.56), positive = kosmopolitisch (Volt +0.27) — see `docs/solutions/best-practices/overton-window-shift-methodology-2026-05-24.md`

ARCHITECTURE.md

@@ -1,69 +1,81 @@
-# ARCHITECTURE
+---
+title: ARCHITECTURE
+---
 
 ## Overview
 
-- Small Python project that collects, stores and presents Dutch parliamentary motions (Tweede Kamer). Itingests votes (OData API or HTML scraping), stores motions in a DuckDB file, generates short humansummaries using an LLM client, and exposes a Streamlit UI for users to vote and view matching results.
+- Small Python project that collects, stores and presents Dutch parliamentary motions (Tweede Kamer). It ingests votes via OData API, stores motions in a DuckDB file, generates short human-readable summaries using an LLM client, and exposes a Streamlit UI for users to vote and view matching results.
 
 ## Tech stack
 
 - Language: Python (single-project repository)
-- Data: DuckDB (file: data/motions.db), ibis used in a small utility (read.py)
-- Web / UI: Streamlit (app.py)
-- HTTP: requests
-- HTML parsing: BeautifulSoup (scraper.py)
-- Scheduling: schedule (scheduler.py)
-- LLM: QWEN (via OpenRouter) / OpenAI-compatible client (summarizer.py uses an OpenRouter/OpenAI-compatible client configured via config). Prefer QWEN via OpenRouter where possible.
-- Packaging: pyproject.toml present
+- Data: DuckDB (file: data/motions.db)
+- Web / UI: Streamlit (app.py, pages/)
+- HTTP: requests (ai_provider.py, api_client.py)
+- LLM: QWEN (via OpenRouter) / OpenAI-compatible client (ai_provider.py). Prefer QWEN via OpenRouter where possible.
+- Analysis: scipy (SVD), scikit-learn (clustering), umap-learn (dimensionality reduction)
+- Visualization: Plotly
+- Packaging: pyproject.toml
 
 ## Top-level layout (annotated)
 
 ./
-
-- app.py               — Streamlit UI, main UI flow and session handling (entrypoint for web)
-- main.py              — minimal CLI entry / small script
+- app.py               — Streamlit UI entrypoint (Home.py routing)
+- Home.py              — Thin wrapper with minimal logic
 - database.py          — MotionDatabase: DuckDB schema, insert/query/update, party-match calculations
 - api_client.py        — TweedeKamerAPI: fetch OData voting records and group into motions
-- scraper.py           — MotionScraper: HTML fallback scraper for motion pages
 - summarizer.py        — MotionSummarizer: LLM integration to generate layman_explanation
-- scheduler.py         — DataUpdateScheduler: initial historical loads + periodic scheduled updates
 - config.py            — Config dataclass: central configuration (DATABASE_PATH, API/AI settings, constants)
-- read.py              — small ibis + duckdb demonstration/utility
-- fix_database.py      — script to recreate/reset DuckDB schema
-- reset.py / verify.py — small maintenance scripts that call into database module
-- test.py              — ad-hoc test script (manual insert/verification)
-- data/                — data/motions.db (DuckDB file)
+- ai_provider.py       — Lightweight HTTP wrapper around OpenRouter/OpenAI-style backends
+- explorer.py          — Explorer page logic, tab routing, SVD visualization
+- explorer_helpers.py  — Pure functions for chart builders, coordinate computation
+- data/                — data/motions.db (DuckDB file, ~18GB)
 - pyproject.toml       — project metadata / dependencies
 - .env                 — environment variables (not printed here)
 
+## Directory structure
+
+- `pages/`             — Streamlit pages: 1_Stemwijzer.py, 2_Explorer.py
+- `pipeline/`          — Data ingestion pipelines: run_pipeline.py, svd_pipeline.py, text_pipeline.py
+- `analysis/`          — SVD, clustering, trajectory, visualization modules
+- `similarity/`        — Embedding-based similarity computation
+- `scripts/`           — Utility scripts for data processing
+- `tests/`             — Test suite using pytest
+- `migrations/`        — SQL migration files
+
 ## Core components
 
-- Streamlit UI (app.py)
+- Streamlit UI (app.py + pages/)
   - Presents the voting UI, reads filtered motions from database, creates sessions, writes user votes
-  - Calls: database.get_filtered_motions(), database.create_session(), database.update_user_vote(),database.calculate_party_matches(), summarizer.update_motion_summaries()
+  - Explorer page (explorer.py) provides SVD visualization and party trajectory analysis
 - Storage (database.py)
   - MotionDatabase encapsulates DuckDB schema creation and CRUD for motions and user sessions
   - Exposes a module-level instance `db = MotionDatabase()` used across the codebase
-  - Key responsibilities: insert_motion, get_filtered_motions, create_session, update_user_vote,calculate_party_matches
-- Ingestion (api_client.py + scraper.py)
+  - Key responsibilities: insert_motion, get_filtered_motions, create_session, update_user_vote, calculate_party_matches
+- Ingestion (api_client.py + pipeline/)
   - api_client.py fetches votes via Tweede Kamer OData API and groups records into motions
-  - scraper.py is an HTML fallback that scrapes motion pages and extracts vote info
-  - Both provide structured motion dicts consumed by database.insert_motion()
+  - pipeline/ orchestrates the full ingestion and analysis workflow
 - Summarization (summarizer.py)
   - Wraps an OpenRouter/OpenAI-compatible client (QWEN via OpenRouter recommended) to produce short layman explanations and persists them to DB
   - Reads motions without layman_explanation and updates rows
-- Orchestration (scheduler.py)
-  - Runs initial historical ingestion and schedules periodic updates (using schedule)
-  - Calls API client and summarizer and writes to the database
+- Analysis (analysis/)
+  - SVD decomposition of voting patterns
+  - UMAP for visualization
+  - Clustering for motion grouping
+  - Trajectory computation for party movement over time
 
 ## Data flow (high level)
 
 1.  Ingestion
-    - scheduler / manual run triggers TweedeKamerAPI.get_motions(...) or MotionScraper.run_scraping_job()
+    - Pipeline triggers TweedeKamerAPI.get_motions(...)
     - Each produced motion dict is passed to MotionDatabase.insert_motion()
     - insert_motion writes to DuckDB (data/motions.db)
 2.  Enrichment
-    - summarizer.update_motion_summaries() reads motions lacking layman_explanation, calls the LLM client (OpenRouter/OpenAI-compatible client) and writes summary text back to the DB
-3.  Presentation / Interaction
+    - summarizer.update_motion_summaries() reads motions lacking layman_explanation, calls the LLM client and writes summary text back to the DB
+3.  Analysis
+    - pipeline/svd_pipeline.py computes SVD embeddings from vote matrix
+    - Results stored in svd_vectors table for visualization
+4.  Presentation / Interaction
     - app.py (Streamlit) queries motions via db.get_filtered_motions() and displays them
     - Users vote; app.py writes votes into the database via db.update_user_vote()
     - app.py calls db.calculate_party_matches() to compute match percentages for parties
@@ -72,42 +84,45 @@
 
 - Tweede Kamer OData API (api_client.py)
 - HTTP (requests)
-- HTML parsing (BeautifulSoup) used by scraper.py
 - DuckDB (database file at data/motions.db)
-- ibis (read.py demonstrates an ibis.duckdb connection)
 - Streamlit for UI
-- OpenRouter/OpenAI-compatible LLM client (summarizer.py) — configured with environment variables in config.py. Prefer using OPENROUTER_API_KEY with OPENAI_API_KEY as a fallback where appropriate.
+- OpenRouter/OpenAI-compatible LLM client (ai_provider.py) — configured with environment variables in config.py
 
 ## Configuration
 
 - config.py: central Config dataclass. Observed keys / env variables referenced across the codebase include:
   - config.DATABASE_PATH (default "data/motions.db")
-  - OPENROUTER_API_KEY / other OPENROUTER_* variables used by summarizer.py
+  - OPENROUTER_API_KEY / other OPENROUTER_* variables used by ai_provider.py
   - QWEN_MODEL (or other model identifier) referenced in summarizer.py
   - API timeout / batch size constants
-- .env file present at repo root (do not commit secrets). See .env.example if present (none observed).
+- .env file present at repo root (do not commit secrets)
 - Packaging metadata: pyproject.toml
 
 ## Build, run & development notes
 
-- Install dependencies via the project's Python packaging (pyproject.toml). There is no Dockerfile or CIworkflows detected in the repository.
-- Use uv add and uv run to manage the dependencies in this directory and run scripts
-- Streamlit app: run `uv run streamlit run app.py` from project root to start the UI (app.py is the intended web entrypoint).
-- Scheduler: run scheduler.run_once() (script or import) or run scheduler.run_scheduler() for periodic ingestion.
+- Install dependencies via the project's Python packaging (pyproject.toml)
+- Use `uv add` and `uv run` to manage the dependencies in this directory and run scripts
+- Streamlit app: run `uv run streamlit run app.py` from project root to start the UI (app.py is the intended web entrypoint)
+- Never use pip directly!
+- Run tests: `uv run pytest tests/`
 
 ## Tests
 
-- There is no test suite using pytest / unittest. One ad-hoc script `test.py` exists for manual insert verification.
+- Test suite in `tests/` using pytest
+- Run with `uv run pytest tests/`
 
 ## Notes / caveats
 
-- Project is synchronous (no async/await patterns detected). Many modules rely on module-level singletons(e.g., `db = MotionDatabase()`, `summarizer = MotionSummarizer()`, `scraper = MotionScraper()`).
-- Error handling frequently catches broad Exception and prints to stdout (see database.py, api_client.py,scraper.py). Logging is not centralized (print statements used).
+- Project is synchronous (no async/await patterns detected)
+- Many modules rely on module-level singletons (e.g., `db = MotionDatabase()`, `summarizer = MotionSummarizer()`)
+- Error handling frequently catches broad Exception and prints to stdout (see database.py, api_client.py)
+- Logging is not centralized (print statements used)
 
 ## Where to look first (for contributors)
 
-- app.py            — follow the UI flow and see how votes & sessions are used
-- database.py       — core data model and calculations
-- api_client.py     — OData ingestion logic
-- summarizer.py     — LLM usage and environment variables
-- scheduler.py      — how ingestion is orchestrated over time
+- app.py + pages/     — follow the UI flow and see how votes & sessions are used
+- database.py          — core data model and calculations
+- explorer.py          — SVD visualization and party analysis
+- api_client.py        — OData ingestion logic
+- summarizer.py        — LLM usage and environment variables
+- pipeline/            — how ingestion and analysis is orchestrated

Dockerfile

@@ -1,32 +0,0 @@
-FROM python:3.13-slim
-
-# Install minimal system deps
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends build-essential curl ca-certificates \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create non-root user for running the app
-RUN useradd -m -s /bin/bash app
-
-WORKDIR /home/app/app
-
-# Copy project files
-COPY . /home/app/app
-
-# Upgrade pip and install all project dependencies from pyproject.toml
-RUN python -m pip install --upgrade pip
-RUN pip install .
-
-# Fix permissions
-RUN chown -R app:app /home/app
-
-USER app
-ENV PYTHONPATH=/home/app/app
-
-EXPOSE 8501
-
-# Simple healthcheck that queries the Streamlit root
-HEALTHCHECK --interval=30s --timeout=3s --start-period=10s CMD curl -f http://localhost:8501/ || exit 1
-
-# Run the multi-page Streamlit app
-CMD ["streamlit", "run", "Home.py", "--server.port=8501", "--server.address=0.0.0.0"]

Home.py

@@ -1,53 +1,51 @@
-"""StemAtlas — home page.
+"""StemAtlas — navigation entry point.
 
-Entry point for the Streamlit multi-page app. Shows a landing page with
-brief descriptions of and links to the two sub-pages.
+Uses st.navigation() for explicit control over page order and default page.
+Run with: uv run streamlit run Home.py
 """
 
 import streamlit as st
 
 st.set_page_config(
     page_title="StemAtlas",
-    page_icon="🗺️",
+    page_icon=None,
     layout="centered",
-    initial_sidebar_state="expanded",
 )
 
+# Hide Streamlit chrome and add mobile-friendly styles.
+st.markdown(
+    """
+    <style>
+    .stAppDeployButton { display: none !important; }
+    .stStatusWidget { display: none !important; }
+    header [data-testid="stToolbar"] { display: none !important; }
 
-def main() -> None:
-    st.title("🗺️ StemAtlas")
-    st.markdown(
-        "**StemAtlas** brengt de Nederlandse Tweede Kamer in kaart op basis van "
-        "echte stemmingen over moties. Gebruik de Stemwijzer om te ontdekken welke "
-        "partij het beste bij jouw standpunten past, of verken de politieke ruimte "
-        "zelf in de Explorer."
-    )
+    /* Mobile-friendly touch targets and readability */
+    @media (max-width: 768px) {
+        .stButton button {
+            min-height: 48px !important;
+            font-size: 16px !important;
+        }
+        .stRadio label {
+            font-size: 16px !important;
+        }
+        .stSelectbox label, .stSlider label, .stNumberInput label {
+            font-size: 15px !important;
+        }
+        h1 { font-size: 1.6rem !important; }
+        h2 { font-size: 1.3rem !important; }
+        h3 { font-size: 1.1rem !important; }
+    }
 
-    st.divider()
+    /* Prevent horizontal overflow */
+    .stApp { max-width: 100vw; overflow-x: hidden; }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
 
-    col1, col2 = st.columns(2)
+explorer = st.Page("pages/2_Explorer.py", title="Explorer", default=True)
+stemwijzer = st.Page("pages/1_Stemwijzer.py", title="Stemwijzer")
 
-    with col1:
-        st.subheader("🗳️ Stemwijzer")
-        st.markdown(
-            "Stem op echte Tweede Kamer moties en zie welke partij het "
-            "dichtst bij jouw keuzes staat."
-        )
-        st.page_link("pages/1_Stemwijzer.py", label="Open Stemwijzer", icon="🗳️")
-
-    with col2:
-        st.subheader("🔭 Politiek Explorer")
-        st.markdown(
-            "Verken het politieke kompas, partijtrajecten door de tijd, "
-            "en zoek vergelijkbare moties op in het archief."
-        )
-        st.page_link("pages/2_Explorer.py", label="Open Explorer", icon="🔭")
-
-    st.divider()
-    st.caption(
-        "Data: Tweede Kamer API · Embeddings: QWEN (via OpenRouter) · "
-        "Gemaakt door [Sven Geboers](https://sgeboers.nl)"
-    )
-
-
-main()
+pg = st.navigation([explorer, stemwijzer])
+pg.run()

README.md

@@ -1,22 +1,85 @@
-# stemwijzer
+# Stemwijzer
 
-A small project that uses QWEN embeddings for semantic features. The codebase includes an example Ansible package under packages/@ansible/example and helper scripts for deployment.
+A Dutch parliamentary voting compass that lets you vote on real Tweede Kamer motions and see which parties match your positions.
 
-Embeddings
-- This project uses QWEN embeddings (model: `qwen/qwen3-embedding-4b`) via OpenRouter-compatible APIs.
-- Preferred environment variable: `OPENROUTER_API_KEY` with a fallback to `OPENAI_API_KEY`.
+![Stemwijzer Explorer](docs/assets/stemwijzer-screenshot.png)
 
-Publishing and deploying the Ansible package
+## What is Stemwijzer?
 
-- Package location: `packages/@ansible/example` — this contains the Ansible playbooks and packaging used by CI.
-- To publish the package (CI): create a git tag for the version and provide `NPM_TOKEN` as a secret to the CI runner so it can publish to npm.
-- To deploy the package (CI): set the following repository secrets in your CI pipeline:
-  - `DEPLOY_HOST` (default: `motief.sgeboers.nl`)
-  - `DEPLOY_SSH_KEY` (private key for the `webapps` user)
-  - `DEPLOY_USER` (default: `webapps`)
+Stemwijzer ingests motions and voting records from the Dutch House of Representatives (Tweede Kamer), stores them in DuckDB, generates AI-powered explanations with an LLM, and presents a Streamlit UI where users can vote on real motions and explore party positions through SVD visualizations, trajectory analysis, and embedding-based similarity search.
 
-Defaults
-- DEPLOY_HOST: `motief.sgeboers.nl`
-- DEPLOY_USER: `webapps`
+## Features
 
-See docs/deployment/ansible-package-deploy.md for more detailed deploy instructions and defaults.
+- **Voting Compass** — Vote on real parliamentary motions and see which parties align with your choices
+- **Explorer** — Interactive SVD visualizations, party trajectories over time, motion browser, and semantic search
+- **Analytics** — SVD decomposition of voting patterns, UMAP projections, clustering, and drift analysis
+- **LLM Enrichment** — Automatic generation of layman-friendly motion explanations using QWEN via OpenRouter
+- **Overton Window Analysis** — Quantitative analysis of whether the Dutch parliamentary center has shifted rightward, using centrist voting support, SVD spatial drift, 2D extremity scoring, and mechanism classification
+
+## Prerequisites
+
+- Python >= 3.13
+- [uv](https://docs.astral.sh/uv/) for dependency management
+- (Optional) `OPENROUTER_API_KEY` for LLM enrichment
+
+## Quickstart
+
+```bash
+# Clone and enter the repository
+git clone <your-gitea-url>/sgeboers/stemwijzer.git
+cd stemwijzer
+
+# Install dependencies
+uv sync
+
+# Run the Streamlit app
+uv run streamlit run Home.py
+
+# Run the data pipeline (fetch motions, compute embeddings, etc.)
+uv run python pipeline/run_pipeline.py
+
+# Run tests
+uv run pytest tests/ -q
+```
+
+The app will be available at http://localhost:8501.
+
+## Project Structure
+
+```
+├── app.py              # Streamlit UI entrypoint
+├── database.py         # DuckDB schema and queries
+├── api_client.py       # Tweede Kamer OData API client
+├── explorer.py         # Explorer page with SVD visualizations
+├── pipeline/           # Data ingestion and analysis pipelines
+├── analysis/           # SVD, clustering, trajectory, right-wing motion analysis
+├── tests/              # pytest test suite
+├── docs/               # Documentation, research, and plans
+└── data/motions.db     # DuckDB database (~18 GB)
+```
+
+## Documentation
+
+- **[ARCHITECTURE.md](ARCHITECTURE.md)** — Comprehensive architecture overview, tech stack, and contributor guidance
+- **[CODE_STYLE.md](CODE_STYLE.md)** — Coding conventions, naming, typing, and testing standards
+- **[docs/solutions/](docs/solutions/)** — Documented solutions to past bugs and best practices
+
+### Research
+
+- **[Overton Window Article](reports/overton_window/overton_window.qmd)** — Interactive article: "Has the Dutch Overton window shifted?" with Plotly charts (render with `quarto render`)
+- **[Overton Synthesis](reports/overton_window/overton_window_synthesis.md)** — Detailed synthesis of all indicators and the "acceptance through moderation" verdict
+- **[Overton Reports](reports/overton_window/)** — 13 appendix reports covering breakpoint analysis, SVD drift, 2D extremity, mechanisms, and more ([reading guide](reports/overton_window/README.md))
+- **[Overton Dashboard](reports/overton_window/overton_report.html)** — Standalone HTML report with gravity-controlled charts and example motions
+
+## Tech Stack
+
+- **Language:** Python 3.13+
+- **Data:** DuckDB via ibis-framework
+- **UI:** Streamlit + Plotly
+- **ML/Analysis:** scipy, scikit-learn, umap-learn
+- **LLM:** QWEN via OpenRouter (OpenAI-compatible)
+- **Package Manager:** uv
+
+## License
+
+[Your license here]

STRATEGY.md

@@ -0,0 +1,59 @@
+---
+name: Stemwijzer
+last_updated: 2026-05-04
+---
+
+# Stemwijzer Strategy
+
+## Target problem
+
+Voters in the Netherlands lack accessible, data-driven tools to understand how political parties actually vote in parliament versus how they present themselves. Existing voting compasses are either static (updated once per election cycle) or based on party self-assessment rather than real voting records.
+
+## Our approach
+
+Build the most transparent, data-grounded political compass by ingesting every parliamentary vote from the Tweede Kamer's public API, computing latent political dimensions via SVD, and letting users vote on real motions to see which parties actually align with their positions — not just what parties claim.
+
+## Who it's for
+
+**Primary:** Politically curious Dutch voters who want to move beyond party branding and understand actual parliamentary behavior. They're hiring Stemwijzer to make an informed voting decision based on data rather than rhetoric.
+
+## Key metrics
+
+- **Motion coverage** — Percentage of parliamentary motions ingested and available for voting; measured in `data/motions.db`
+- **User-session completion rate** — Share of users who vote on at least 10 motions before exiting; measured via Streamlit session state
+- **Party-match accuracy** — How well the SVD-derived party positions predict actual voting alignment; measured via cross-validation on held-out motions
+- **Pipeline freshness** — Days since last successful pipeline run (fetch → embeddings → SVD); measured via `scripts/health_check.py`
+- **Exploration depth** — Average number of tabs visited per session (compass, trajectories, SVD components); measured via Streamlit
+
+## Tracks
+
+### Data pipeline reliability
+
+Make the data ingestion and analysis pipeline robust enough to run unattended and recover from failures.
+
+_Why it serves the approach:_ The entire product depends on accurate, up-to-date voting data. If the pipeline breaks, the compass becomes stale and untrustworthy.
+
+### Analytical depth and transparency
+
+Deepen the SVD analysis and make the political dimensions interpretable and explorable — not just a black-box score.
+
+_Why it serves the approach:_ Users need to trust and understand why parties are positioned where they are. Raw scores without explanation are no better than party branding.
+
+### Agent-native architecture
+
+Restructure the codebase so that agents can safely explore, test, and modify it without human hand-holding — comprehensive tests, clear contracts, and self-documenting structure.
+
+_Why it serves the approach:_ A data-driven product requires constant iteration on analysis methods, visualizations, and feature experiments. Making the codebase agent-native enables rapid, safe iteration.
+
+## Not working on
+
+- Mobile native apps — the web-based Streamlit UI is sufficient for the target audience
+- Social features (sharing, leaderboards, discussions) — the product is a research tool, not a social network
+- Predictive modeling of election outcomes — the focus is on transparency of past/current voting, not forecasting
+- Multi-language support — Dutch parliament, Dutch voters, Dutch UI
+
+## Marketing
+
+**One-liner:** Stemwijzer — vote on real parliamentary motions and discover which parties actually match your politics.
+
+**Key message:** Every vote in the Tweede Kamer is public. We compute the patterns, you discover where you fit.

agent_tools/SYSTEM_PROMPT.md

@@ -0,0 +1,82 @@
+# Stemwijzer Agent System Prompt
+
+You are the **Stemwijzer Pipeline Operator** — an autonomous agent that operates the Stemwijzer parliamentary voting analysis pipeline.
+
+## Your Identity
+
+- You are methodical, precise, and data-driven.
+- You prefer structured outputs (JSON, markdown tables) over prose.
+- You always verify assumptions with data before making claims.
+- You write reports to `reports/` and accumulate learnings in `agent_tools/context.md`.
+
+## Your Capabilities
+
+You have access to these atomic tools. Always use them instead of raw SQL or direct module calls.
+
+### Database Queries (`agent_tools.database`)
+- `query_motions(db_path, limit, policy_area, start_date, end_date)` — Query motions with filters
+- `query_votes(db_path, motion_id, party)` — Query votes for a motion
+- `query_svd_vectors(db_path, window_id, entity_type)` — Query SVD vectors
+- `query_party_positions(db_path, window_id)` — Query party axis scores
+- `compute_party_positions_from_vectors(db_path, window_id)` — Compute positions when pre-computed table is unavailable
+- `query_pipeline_status(db_path)` — Get pipeline freshness and coverage metrics
+- `query_embeddings(db_path, motion_id, model, limit)` — Query text/fused embeddings
+- `query_similar_motions(db_path, motion_id, top_k)` — Query similar motions from similarity cache
+- `query_compass_positions(db_path, window_id)` — Query 2D compass positions for parties/MPs
+- `create_motion(db_path, title, description, date, ...)` — Insert a new motion
+- `update_motion(db_path, motion_id, **fields)` — Update an existing motion
+- `delete_report(output_path)` — Delete a generated report file
+
+### Pipeline Control (`agent_tools.pipeline`)
+- `pipeline_run_stage(db_path, stage, window_id, dry_run)` — Run one pipeline stage
+- `pipeline_get_logs(stage, lines)` — Get recent log output for a stage
+
+### Content Validation (`agent_tools.content`)
+- `validate_motion_coverage(db_path, start_date, end_date)` — Find data gaps
+- `validate_layman_explanations(db_path, sample_size)` — Check explanation quality
+- `check_embedding_quality(db_path, window_id)` — Measure embedding coverage
+
+### Context & Discovery (`agent_tools.context` + `agent_tools`)
+- `list_tools()` — Runtime discovery of all available tools
+- `read_context_md()` — Read accumulated agent knowledge
+- `append_context_note(note)` — Write a learning to context.md
+- `list_recent_reports()` — List recently generated report files
+
+## Decision Criteria
+
+### When to use agent_tools vs direct code
+- **Always use `agent_tools`** for database queries, pipeline operations, and content validation
+- Only write direct Python/SQL when `agent_tools` lacks the needed capability
+- Use `list_tools()` when unsure what primitives exist
+
+### When to run the pipeline
+- Data is stale (> 7 days since last motion)
+- Pipeline status shows gaps or failures
+- User explicitly requests fresh data
+
+### When to validate content
+- After pipeline runs
+- When SVD labels look suspicious
+- Before publishing analysis to users
+
+## Output Conventions
+
+1. **Always return structured data** — dicts and lists, not raw prose
+2. **Include `error` keys** when things fail, with actionable suggestions
+3. **Write reports to `reports/`** — ephemeral, human-readable artifacts
+4. **Update `context.md`** when you learn something about the pipeline
+5. **Be explicit about uncertainty** — "Data shows X (n=123)" not "Probably X"
+
+## Knowledge Base
+
+Before making claims about the data, check `docs/solutions/` for documented patterns:
+- SVD labels reflect voting patterns, not semantic content
+- Right-wing parties appear on the RIGHT side of all axes
+- EVR percentages come from `analysis.political_axis.compute_svd_spectrum`
+
+## Safety
+
+- You operate in the same trust boundary as the developer
+- You can read the full database but write only to `reports/` and `context.md`
+- You cannot delete data or modify pipeline logic
+- Always use `dry_run=True` when the user says "what would happen if..."

agent_tools/__init__.py

@@ -0,0 +1,82 @@
+"""Agent tools for Stemwijzer — atomic primitives for agent operation.
+
+Import individual modules or use `list_tools()` for runtime discovery.
+"""
+
+from __future__ import annotations
+
+from agent_tools.context import (
+    append_context_note,
+    list_recent_reports,
+    read_context_md,
+)
+from agent_tools.database import (
+    compute_party_positions_from_vectors,
+    create_motion,
+    delete_report,
+    query_compass_positions,
+    query_embeddings,
+    query_motions,
+    query_party_positions,
+    query_pipeline_status,
+    query_similar_motions,
+    query_svd_vectors,
+    query_votes,
+    update_motion,
+)
+from agent_tools.pipeline import (
+    pipeline_get_logs,
+    pipeline_run_stage,
+)
+
+__all__ = [
+    # Database
+    "query_motions",
+    "query_votes",
+    "query_svd_vectors",
+    "query_party_positions",
+    "compute_party_positions_from_vectors",
+    "query_pipeline_status",
+    "query_embeddings",
+    "query_similar_motions",
+    "query_compass_positions",
+    "create_motion",
+    "update_motion",
+    "delete_report",
+    # Pipeline
+    "pipeline_run_stage",
+    "pipeline_get_logs",
+    # Context
+    "list_recent_reports",
+    "read_context_md",
+    "append_context_note",
+    # Discovery
+    "list_tools",
+]
+
+
+def list_tools() -> list[dict[str, str]]:
+    """Return a list of all available agent tools with signatures and descriptions.
+
+    Useful for runtime capability discovery and prompt injection.
+    """
+    return [
+        {"name": "query_motions", "signature": "query_motions(db_path, limit=100, policy_area=None, start_date=None, end_date=None)", "description": "Query motions from the database with optional filters."},
+        {"name": "query_votes", "signature": "query_votes(db_path, motion_id=None, party=None)", "description": "Query vote counts or individual votes."},
+        {"name": "query_svd_vectors", "signature": "query_svd_vectors(db_path, window_id, entity_type='motion')", "description": "Query SVD vectors for a window and entity type."},
+        {"name": "query_party_positions", "signature": "query_party_positions(db_path, window_id='current_parliament')", "description": "Query party axis positions for a window."},
+        {"name": "compute_party_positions_from_vectors", "signature": "compute_party_positions_from_vectors(db_path, window_id)", "description": "Compute party positions from MP vectors when pre-computed table is unavailable."},
+        {"name": "query_pipeline_status", "signature": "query_pipeline_status(db_path)", "description": "Query pipeline freshness and coverage metrics (raw counts, no judgment)."},
+        {"name": "query_embeddings", "signature": "query_embeddings(db_path, motion_id=None, model=None, limit=100)", "description": "Query text/fused embeddings."},
+        {"name": "query_similar_motions", "signature": "query_similar_motions(db_path, motion_id, top_k=10)", "description": "Query similar motions from similarity cache."},
+        {"name": "query_compass_positions", "signature": "query_compass_positions(db_path, window_id='current_parliament')", "description": "Query 2D compass positions for parties/MPs."},
+        {"name": "create_motion", "signature": "create_motion(db_path, title, description, date, policy_area='General', voting_results='[]')", "description": "Insert a new motion into the database."},
+        {"name": "update_motion", "signature": "update_motion(db_path, motion_id, **fields)", "description": "Update fields of an existing motion."},
+        {"name": "delete_report", "signature": "delete_report(output_path)", "description": "Delete a generated report file."},
+        {"name": "pipeline_run_stage", "signature": "pipeline_run_stage(db_path, stage, window_id, dry_run=False)", "description": "Run a single pipeline stage (agent decides which and when)."},
+        {"name": "pipeline_get_logs", "signature": "pipeline_get_logs(stage, lines=50)", "description": "Retrieve recent log output for a stage."},
+        {"name": "list_recent_reports", "signature": "list_recent_reports()", "description": "List recently generated report files."},
+        {"name": "read_context_md", "signature": "read_context_md()", "description": "Read accumulated agent knowledge from context.md."},
+        {"name": "append_context_note", "signature": "append_context_note(note)", "description": "Append a note to the accumulated agent knowledge."},
+        {"name": "list_tools", "signature": "list_tools()", "description": "Return a list of all available agent tools."},
+    ]

agent_tools/analysis.py

@@ -0,0 +1,10 @@
+"""Analysis primitives for agent operation.
+
+NOTE: Multi-step analytical workflows (party shift, axis stability, SVD label
+validation) have been removed. Agents should compose raw database primitives
+(query_party_positions, query_svd_vectors, etc.) and perform analysis in their
+own reasoning loop.
+
+This module is intentionally empty. If needed, pure computational helpers
+(without business logic) can be added here.
+"""

agent_tools/content.py

@@ -0,0 +1,133 @@
+"""Content validation primitives for agent operation.
+
+Tools for validating data quality, coverage, and content correctness.
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timedelta
+from typing import Any, Dict
+
+from agent_tools.database import query_motions, query_svd_vectors
+
+logger = logging.getLogger(__name__)
+
+
+def validate_motion_coverage(
+    db_path: str,
+    start_date: str,
+    end_date: str,
+) -> Dict[str, Any]:
+    """Validate motion coverage for a date range.
+
+    Returns gaps where no motions exist in the database.
+    """
+    try:
+        motions = query_motions(db_path, limit=10000)
+
+        if not motions:
+            return {
+                "gaps": [{"start": start_date, "end": end_date}],
+                "coverage_rate": 0.0,
+                "total_motions": 0,
+            }
+
+        # Convert dates
+        start = datetime.fromisoformat(start_date)
+        end = datetime.fromisoformat(end_date)
+
+        # Check coverage month by month
+        gaps = []
+        current = start
+        while current < end:
+            month_end = min(current + timedelta(days=31), end)
+            month_motions = [
+                m for m in motions
+                if current <= datetime.fromisoformat(str(m.get("date", "1970-01-01"))) < month_end
+            ]
+            if not month_motions:
+                gaps.append({
+                    "start": current.isoformat(),
+                    "end": month_end.isoformat(),
+                })
+            current = month_end
+
+        total_days = (end - start).days
+        gap_days = sum(
+            (datetime.fromisoformat(g["end"]) - datetime.fromisoformat(g["start"])).days
+            for g in gaps
+        )
+        coverage_rate = round((total_days - gap_days) / total_days, 4) if total_days > 0 else 0.0
+
+        return {
+            "gaps": gaps,
+            "coverage_rate": coverage_rate,
+            "total_motions": len(motions),
+            "date_range": {"start": start_date, "end": end_date},
+        }
+    except Exception as e:
+        logger.exception("validate_motion_coverage failed")
+        return {"gaps": [], "coverage_rate": 0.0, "error": str(e)}
+
+
+def validate_layman_explanations(
+    db_path: str,
+    sample_size: int = 100,
+) -> Dict[str, Any]:
+    """Sample motions and check layman explanation coverage.
+
+    Returns quality metrics for explanations.
+    """
+    try:
+        motions = query_motions(db_path, limit=sample_size)
+
+        if not motions:
+            return {
+                "sample_size": 0,
+                "coverage": 0.0,
+                "empty_count": 0,
+            }
+
+        with_explanation = sum(
+            1 for m in motions
+            if m.get("layman_explanation") and str(m.get("layman_explanation")).strip()
+        )
+
+        return {
+            "sample_size": len(motions),
+            "coverage": round(with_explanation / len(motions), 4),
+            "empty_count": len(motions) - with_explanation,
+            "total_in_db": len(motions),
+        }
+    except Exception as e:
+        logger.exception("validate_layman_explanations failed")
+        return {"sample_size": 0, "coverage": 0.0, "error": str(e)}
+
+
+def check_embedding_quality(
+    db_path: str,
+    window_id: str,
+) -> Dict[str, Any]:
+    """Check embedding coverage for a window.
+
+    Returns raw coverage stats. The agent decides whether coverage is acceptable.
+    """
+    try:
+        vectors = query_svd_vectors(db_path, window_id, entity_type="motion")
+        motions = query_motions(db_path, limit=100000)
+
+        total_motions = len(motions)
+        with_embeddings = len(vectors)
+
+        coverage = round(with_embeddings / total_motions, 4) if total_motions > 0 else 0.0
+
+        return {
+            "window_id": window_id,
+            "total_motions": total_motions,
+            "with_embeddings": with_embeddings,
+            "coverage": coverage,
+        }
+    except Exception as e:
+        logger.exception("check_embedding_quality failed")
+        return {"window_id": window_id, "coverage": 0.0, "error": str(e)}

agent_tools/context.md

@@ -0,0 +1,20 @@
+# Agent Accumulated Context
+
+This file is maintained by the agent. It stores learnings about the pipeline,
+data patterns, and operational notes that persist across sessions.
+
+## How to use this file
+
+- The agent reads this at session start for accumulated context
+- The agent appends new learnings after each significant operation
+- Humans can read this to understand what the agent has discovered
+
+---
+
+## Initial State
+
+Pipeline is fresh. No accumulated learnings yet.
+
+---
+
+*This file grows over time as the agent operates the pipeline.*

agent_tools/context.py

@@ -0,0 +1,52 @@
+"""Runtime context injection for agent operation.
+
+Filesystem primitives for managing agent accumulated knowledge.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from datetime import datetime
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+
+def list_recent_reports() -> List[str]:
+    """List recently generated reports."""
+    try:
+        reports_dir = "reports"
+        if not os.path.exists(reports_dir):
+            return []
+        files = sorted(
+            (f for f in os.listdir(reports_dir) if f.endswith(".md")),
+            key=lambda f: os.path.getmtime(os.path.join(reports_dir, f)),
+            reverse=True,
+        )
+        return files[:10]
+    except Exception:
+        return []
+
+
+def read_context_md() -> str:
+    """Read accumulated knowledge from context.md."""
+    try:
+        path = os.path.join("agent_tools", "context.md")
+        if os.path.exists(path):
+            with open(path, "r", encoding="utf-8") as f:
+                return f.read()
+        return ""
+    except Exception:
+        return ""
+
+
+def append_context_note(note: str) -> None:
+    """Append a learning to context.md."""
+    try:
+        path = os.path.join("agent_tools", "context.md")
+        timestamp = datetime.now().isoformat()
+        with open(path, "a", encoding="utf-8") as f:
+            f.write(f"\n## {timestamp}\n\n{note}\n")
+    except Exception:
+        logger.exception("Failed to append context note")

agent_tools/database.py

@@ -0,0 +1,376 @@
+"""Database query primitives for agent operation.
+
+Thin wrappers around DuckDB that return structured JSON-friendly results.
+All functions accept db_path as first argument and return either list[dict] or dict.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _connect(db_path: str, read_only: bool = True):
+    import duckdb
+
+    return duckdb.connect(database=db_path, read_only=read_only)
+
+
+def query_motions(
+    db_path: str,
+    *,
+    year: Optional[int] = None,
+    policy_area: Optional[str] = None,
+    limit: int = 100,
+    order: str = "date DESC",
+) -> List[Dict[str, Any]]:
+    """Query motions with optional filters."""
+    try:
+        con = _connect(db_path)
+        conditions = []
+        params = []
+
+        if year is not None:
+            conditions.append("EXTRACT(YEAR FROM date) = ?")
+            params.append(year)
+        if policy_area is not None:
+            conditions.append("policy_area = ?")
+            params.append(policy_area)
+
+        where_clause = "WHERE " + " AND ".join(conditions) if conditions else ""
+        sql = f"""
+            SELECT id, title, description, date, policy_area,
+                   winning_margin, controversy_score, layman_explanation
+            FROM motions
+            {where_clause}
+            ORDER BY {order}
+            LIMIT ?
+        """
+        params.append(limit)
+
+        result = con.execute(sql, params).fetchdf().to_dict("records")
+        con.close()
+        return result
+    except Exception:
+        logger.exception("query_motions failed")
+        return []
+
+
+def query_votes(
+    db_path: str,
+    motion_id: int,
+    party: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """Query vote counts for a motion, optionally filtered by party."""
+    try:
+        con = _connect(db_path)
+        if party:
+            sql = """
+                SELECT mp_name, vote
+                FROM mp_votes
+                WHERE motion_id = ? AND mp_name IN (
+                    SELECT mp_name FROM mp_metadata WHERE party = ?
+                )
+            """
+            result = con.execute(sql, (motion_id, party)).fetchdf().to_dict("records")
+        else:
+            sql = "SELECT mp_name, vote FROM mp_votes WHERE motion_id = ?"
+            result = con.execute(sql, (motion_id,)).fetchdf().to_dict("records")
+        con.close()
+        return result
+    except Exception:
+        logger.exception("query_votes failed")
+        return []
+
+
+def query_svd_vectors(
+    db_path: str,
+    window_id: str,
+    entity_type: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """Query SVD vectors for a window."""
+    try:
+        con = _connect(db_path)
+        if entity_type:
+            sql = """
+                SELECT entity_id, vector, model
+                FROM svd_vectors
+                WHERE window_id = ? AND entity_type = ?
+            """
+            result = con.execute(sql, (window_id, entity_type)).fetchdf().to_dict("records")
+        else:
+            sql = """
+                SELECT entity_id, entity_type, vector, model
+                FROM svd_vectors
+                WHERE window_id = ?
+            """
+            result = con.execute(sql, (window_id,)).fetchdf().to_dict("records")
+        con.close()
+        return result
+    except Exception:
+        logger.exception("query_svd_vectors failed")
+        return []
+
+
+def query_party_positions(
+    db_path: str,
+    window_id: str,
+) -> List[Dict[str, Any]]:
+    """Query party axis scores for a window."""
+    try:
+        con = _connect(db_path)
+        tables = con.execute(
+            "SELECT table_name FROM information_schema.tables WHERE table_name = 'party_axis_scores'"
+        ).fetchall()
+
+        if not tables:
+            con.close()
+            return []
+
+        result = con.execute(
+            """
+            SELECT party, axis, score
+            FROM party_axis_scores
+            WHERE window_id = ?
+            """,
+            (window_id,),
+        ).fetchdf().to_dict("records")
+        con.close()
+        return result
+    except Exception:
+        logger.exception("query_party_positions failed")
+        return []
+
+
+def compute_party_positions_from_vectors(con, window_id: str) -> List[Dict[str, Any]]:
+    """Compute party positions from MP vectors.
+
+    This is a separate primitive for when party_axis_scores is not pre-computed.
+    """
+    import duckdb
+    if isinstance(con, str):
+        con = duckdb.connect(database=con, read_only=True)
+        should_close = True
+    else:
+        should_close = False
+    rows = con.execute(
+        """
+        SELECT sv.entity_id, sv.vector, mm.party
+        FROM svd_vectors sv
+        JOIN mp_metadata mm ON sv.entity_id = mm.mp_name
+        WHERE sv.window_id = ? AND sv.entity_type = 'mp'
+        """,
+        (window_id,),
+    ).fetchall()
+
+    import json
+    from collections import defaultdict
+
+    party_vectors = defaultdict(list)
+    for mp_name, vector_json, party in rows:
+        vec = json.loads(vector_json) if isinstance(vector_json, str) else vector_json
+        party_vectors[party].append(vec)
+
+    result = []
+    for party, vectors in party_vectors.items():
+        if not vectors:
+            continue
+        dim = len(vectors[0])
+        mean = [sum(v[i] for v in vectors) / len(vectors) for i in range(min(dim, 2))]
+        result.append({
+            "party": party,
+            "axis_1": mean[0] if len(mean) > 0 else 0.0,
+            "axis_2": mean[1] if len(mean) > 1 else 0.0,
+        })
+
+    if should_close:
+        con.close()
+
+    return result
+
+
+def query_pipeline_status(db_path: str) -> Dict[str, Any]:
+    """Return pipeline freshness metrics."""
+    try:
+        con = _connect(db_path)
+
+        motion_count = con.execute("SELECT COUNT(*) FROM motions").fetchone()[0]
+
+        latest = con.execute("SELECT MAX(date) FROM motions").fetchone()
+        latest_motion_date = latest[0] if latest and latest[0] else None
+
+        svd_windows = con.execute(
+            "SELECT COUNT(DISTINCT window_id) FROM svd_vectors"
+        ).fetchone()[0]
+
+        embedding_count = con.execute(
+            "SELECT COUNT(*) FROM svd_vectors WHERE entity_type = 'motion'"
+        ).fetchone()[0]
+
+        con.close()
+
+        return {
+            "motion_count": motion_count,
+            "latest_motion_date": str(latest_motion_date) if latest_motion_date else None,
+            "svd_window_count": svd_windows,
+            "embedding_count": embedding_count,
+        }
+    except Exception:
+        logger.exception("query_pipeline_status failed")
+        return {
+            "motion_count": 0,
+            "latest_motion_date": None,
+            "svd_window_count": 0,
+            "embedding_count": 0,
+            "error": "Failed to query pipeline status",
+        }
+
+
+def query_embeddings(
+    db_path: str,
+    *,
+    motion_id: Optional[int] = None,
+    model: Optional[str] = None,
+    limit: int = 100,
+) -> List[Dict[str, Any]]:
+    """Query fused embeddings for motions."""
+    try:
+        con = _connect(db_path)
+        conditions = []
+        params = []
+
+        if motion_id is not None:
+            conditions.append("motion_id = ?")
+            params.append(motion_id)
+        if model is not None:
+            conditions.append("model = ?")
+            params.append(model)
+
+        where_clause = "WHERE " + " AND ".join(conditions) if conditions else ""
+        sql = f"""
+            SELECT motion_id, vector, model
+            FROM fused_embeddings
+            {where_clause}
+            LIMIT ?
+        """
+        params.append(limit)
+
+        result = con.execute(sql, params).fetchdf().to_dict("records")
+        con.close()
+        return result
+    except Exception:
+        logger.exception("query_embeddings failed")
+        return []
+
+
+def query_similar_motions(
+    db_path: str,
+    motion_id: int,
+    top_k: int = 10,
+) -> List[Dict[str, Any]]:
+    """Query top-k similar motions from similarity cache."""
+    try:
+        con = _connect(db_path)
+        result = con.execute(
+            """
+            SELECT target_motion_id, similarity_score
+            FROM similarity_cache
+            WHERE source_motion_id = ?
+            ORDER BY similarity_score DESC
+            LIMIT ?
+            """,
+            (motion_id, top_k),
+        ).fetchdf().to_dict("records")
+        con.close()
+        return result
+    except Exception:
+        logger.exception("query_similar_motions failed")
+        return []
+
+
+def query_compass_positions(
+    db_path: str,
+    window_id: str,
+) -> List[Dict[str, Any]]:
+    """Query 2D PCA compass positions for MPs in a window."""
+    try:
+        con = _connect(db_path)
+        result = con.execute(
+            """
+            SELECT sv.entity_id, sv.vector, mm.party
+            FROM svd_vectors sv
+            JOIN mp_metadata mm ON sv.entity_id = mm.mp_name
+            WHERE sv.window_id = ? AND sv.entity_type = 'mp'
+            """,
+            (window_id,),
+        ).fetchdf().to_dict("records")
+        con.close()
+        return result
+    except Exception:
+        logger.exception("query_compass_positions failed")
+        return []
+
+
+def create_motion(
+    db_path: str,
+    title: str,
+    description: str = "",
+    date: str = "",
+    policy_area: str = "",
+) -> Dict[str, Any]:
+    """Create a new motion record."""
+    try:
+        con = _connect(db_path, read_only=False)
+        con.execute(
+            """
+            INSERT INTO motions (title, description, date, policy_area)
+            VALUES (?, ?, ?, ?)
+            """,
+            (title, description, date, policy_area),
+        )
+        con.close()
+        return {"created": True, "title": title}
+    except Exception:
+        logger.exception("create_motion failed")
+        return {"created": False, "error": "Failed to create motion"}
+
+
+def update_motion(
+    db_path: str,
+    motion_id: int,
+    **fields: str,
+) -> Dict[str, Any]:
+    """Update a motion record."""
+    try:
+        con = _connect(db_path, read_only=False)
+        allowed = {"title", "description", "date", "policy_area", "layman_explanation"}
+        updates = {k: v for k, v in fields.items() if k in allowed}
+        if not updates:
+            return {"updated": False, "error": "No valid fields to update"}
+
+        set_clause = ", ".join(f"{k} = ?" for k in updates)
+        params = list(updates.values()) + [motion_id]
+        con.execute(
+            f"UPDATE motions SET {set_clause} WHERE id = ?",
+            params,
+        )
+        con.close()
+        return {"updated": True, "motion_id": motion_id, "fields": list(updates.keys())}
+    except Exception:
+        logger.exception("update_motion failed")
+        return {"updated": False, "error": "Failed to update motion"}
+
+
+def delete_report(output_path: str) -> Dict[str, Any]:
+    """Delete a generated report file."""
+    try:
+        import os
+        if os.path.exists(output_path):
+            os.remove(output_path)
+            return {"deleted": True, "path": output_path}
+        return {"deleted": False, "error": "File not found"}
+    except Exception:
+        logger.exception("delete_report failed")
+        return {"deleted": False, "error": "Failed to delete report"}

agent_tools/pipeline.py

@@ -0,0 +1,60 @@
+"""Pipeline control primitives for agent operation.
+
+Thin execution wrappers. The agent decides which stages to run and in what order.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def pipeline_run_stage(
+    db_path: str,
+    stage: str,
+    window_id: Optional[str] = None,
+    dry_run: bool = False,
+) -> Dict[str, Any]:
+    """Run a single pipeline stage.
+
+    Args:
+        db_path: Path to DuckDB database
+        stage: Pipeline stage name (e.g. "ingestion", "svd", "similarity")
+        window_id: Optional window identifier (e.g. "2024", "current_parliament")
+        dry_run: If True, return planned actions without executing
+
+    Returns:
+        dict with status and metadata
+    """
+    result = {
+        "stage": stage,
+        "window_id": window_id,
+        "dry_run": dry_run,
+        "status": "planned" if dry_run else "not_implemented",
+    }
+
+    if dry_run:
+        return result
+
+    # Actual execution would delegate to pipeline/run_pipeline.py
+    # For now, mark as not implemented — the agent can still plan and diagnose
+    logger.info("pipeline_run_stage: %s (dry_run=%s)", stage, dry_run)
+    return result
+
+
+def pipeline_get_logs(
+    db_path: str,
+    stage: Optional[str] = None,
+    lines: int = 50,
+) -> List[str]:
+    """Return recent log lines for a stage.
+
+    Note: This is a placeholder. In a full implementation, this would read
+    from a structured log store or log files.
+    """
+    # Placeholder: return empty list
+    # Real implementation would read from logging infrastructure
+    logger.info("pipeline_get_logs requested for stage=%s lines=%d", stage, lines)
+    return []

agent_tools/reports.py

@@ -0,0 +1,8 @@
+"""Report generation primitives for agent operation.
+
+NOTE: The report template engine (generate_report, _render_report) has been
+removed. Agents should compose markdown in their reasoning loop and write it
+directly using standard file I/O.
+
+This module is intentionally empty.
+"""

ai_provider.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import os
 import time
 import random
+from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
 from email.utils import parsedate_to_datetime
 from typing import Any
@@ -55,8 +56,8 @@ def _post_with_retries(
     backoff = 0.5
     for attempt in range(1, retries + 1):
         try:
-            resp = requests.post(url, json=json, headers=headers, timeout=10)
-        except requests.ConnectionError as exc:
+            resp = requests.post(url, json=json, headers=headers, timeout=60)
+        except (requests.ConnectionError, requests.Timeout) as exc:
             if attempt == retries:
                 raise ProviderError(
                     f"Connection error when calling provider: {exc}"
@@ -287,3 +288,88 @@ def chat_completion(messages: list[dict], model: str | None = None) -> str:
         ) from exc
 
     return str(content)
+
+
+def chat_completion_json(
+    messages: list[dict],
+    model: str | None = None,
+    json_schema: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Return parsed JSON from a chat completion request using JSON mode.
+
+    Some OpenRouter models (e.g., Google Gemma 4) support native JSON output via
+    the OpenAI-compatible response_format field. We request type='json_object' and
+    optionally supply a JSON schema in the top-level json_schema key.
+    """
+    if not isinstance(messages, list):
+        raise ProviderError("messages must be a list of dicts")
+
+    if model is None:
+        model = (
+            os.environ.get("QWEN_MODEL")
+            or os.environ.get("CHAT_MODEL")
+            or "qwen/qwen-3.2"
+        )
+
+    payload: dict[str, Any] = {"model": model, "messages": messages}
+
+    # Prefer explicit JSON schema (supported by some providers/OpenAI spec)
+    if json_schema is not None:
+        payload["response_format"] = {
+            "type": "json_schema",
+            "json_schema": json_schema,
+        }
+    else:
+        # Fallback: simple JSON object mode
+        payload["response_format"] = {"type": "json_object"}
+
+    resp = _post_with_retries("/chat/completions", json=payload)
+
+    try:
+        data = resp.json()
+    except Exception as exc:
+        raise ProviderError(f"Invalid JSON response from provider: {exc}") from exc
+
+    try:
+        content = data["choices"][0]["message"]["content"]
+    except Exception as exc:
+        raise ProviderError(
+            f"Unexpected chat completion response shape: {data}"
+        ) from exc
+
+    import json as _json
+
+    try:
+        parsed = _json.loads(content)
+    except Exception as exc:
+        raise ProviderError(f"Model returned invalid JSON: {exc}") from exc
+
+    if not isinstance(parsed, dict):
+        raise ProviderError(f"Expected JSON object, got {type(parsed).__name__}")
+
+    return parsed
+
+
+def chat_completion_json_parallel(
+    message_batches: list[list[dict]],
+    model: str | None = None,
+    json_schema: dict[str, Any] | None = None,
+    max_workers: int = 3,
+) -> list[dict[str, Any]]:
+    """Send multiple chat completion requests in parallel and return parsed JSON for each.
+
+    Useful for saturating the API when the provider supports concurrent requests.
+    Each item in message_batches is a separate conversation (list of messages).
+    Returns a list of parsed JSON dicts in the same order as the input batches.
+    """
+    if not message_batches:
+        return []
+
+    def _fetch_one(messages: list[dict]) -> dict[str, Any]:
+        return chat_completion_json(messages, model=model, json_schema=json_schema)
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = [executor.submit(_fetch_one, batch) for batch in message_batches]
+        results = [f.result() for f in futures]
+
+    return results

analysis/axis_classifier.py

@@ -0,0 +1,659 @@
+"""Axis classifier: correlate per-party PCA positions against ideology reference data
+to assign honest, dynamic labels to political compass axes.
+
+Public API: classify_axes(positions_by_window, axes, db_path) -> dict
+"""
+
+import logging
+from collections import Counter
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import re
+import json
+
+from analysis.svd_labels import get_svd_label, get_fallback_labels
+
+_logger = logging.getLogger(__name__)
+
+# Module-level caches — loaded once per process lifetime.
+_ideology_cache: Optional[Dict[str, Dict[str, float]]] = None
+_coalition_cache: Optional[Dict[str, set]] = None
+
+# Correlation threshold above which we consider an axis "explained" by a dimension.
+_THRESHOLD = 0.65
+
+_LABELS = {
+    "lr": "Verzorgingsstaat–Marktwerking",
+    "eu": "EU-integratie–Nationalisme",
+    "pi": "Populistisch–Institutioneel",
+    "co": "Coalitie–Oppositie",
+    "pc": "Conservatief–Progressief",
+    # When we have no interpretable classifier signal, fall back to the known
+    # SVD component meanings rather than generic "As N" labels.
+    "fallback_x": get_svd_label(1),
+    "fallback_y": get_svd_label(2),
+}
+
+
+# Module-level helper: map internal/modal labels to user-facing labels.
+# Remove duplicate lower definition (keep the one at the top)
+
+
+def display_label_for_modal(modal_label: Optional[str], axis: str) -> str:
+    """Return a user-facing axis label for a modal/internal label.
+
+    Maps numeric fallback names 'As 1' / 'Stempatroon As 1' to the
+    semantic labels from SVD_THEMES. Any other label is returned unchanged.
+    None is treated as the semantic fallback for the axis.
+    """
+    if modal_label is None:
+        # Fallback to component 1 (x) or 2 (y)
+        comp = 1 if axis == "x" else 2
+        return get_svd_label(comp)
+
+    # Map "As 1" / "As 2" to semantic labels
+    if axis == "x" and modal_label in ("As 1", "Stempatroon As 1"):
+        return get_svd_label(1)
+    if axis == "y" and modal_label in ("As 2", "Stempatroon As 2"):
+        return get_svd_label(2)
+
+    return modal_label
+
+
+_INTERPRETATION_TEMPLATES = {
+    "lr": "De {orientation} as weerspiegelt de economische tegenstelling tussen verzorgingsstaat en marktwerking.",
+    "eu": "De {orientation} as weerspiegelt de tegenstelling tussen EU-integratie/internationalisme en nationalisme/soevereiniteit.",
+    "pi": "De {orientation} as scheidt populistisch-nationalistische partijen van het institutioneel-parlementaire establishment.",
+    "co": (
+        "De {orientation} as weerspiegelt stemgedrag van coalitie- versus "
+        "oppositiepartijen (r={r:.2f}). Ideologische tegenstellingen zijn minder dominant dit jaar."
+    ),
+    "pc": "De {orientation} as weerspiegelt de progressief-conservatieve tegenstelling.",
+}
+
+# Maps motion-path keyword labels to _INTERPRETATION_TEMPLATES keys.
+# Labels not present here fall back to "fallback".
+_MOTION_LABEL_TEMPLATE_KEY: Dict[str, str] = {
+    "Verzorgingsstaat–Marktwerking": "lr",
+    "EU-integratie–Nationalisme": "eu",
+    "Populistisch–Institutioneel": "pi",
+    "Progressief–Conservatief": "pc",
+}
+
+
+# Simple keyword-based classifier for motion titles (fallback signal)
+_KEYWORD_THRESHOLD = 0.4
+
+_KEYWORDS: Dict[str, List[str]] = {
+    "Verzorgingsstaat–Marktwerking": [
+        # economic / welfare state
+        "belasting",
+        "uitkering",
+        "bijstand",
+        "minimumloon",
+        "cao",
+        "vakbond",
+        "bezuiniging",
+        "privatisering",
+        "subsidie",
+        "pensioen",
+        "aow",
+        "zorg",
+        "huur",
+        "woning",
+        "sociaal",
+        "werkloos",
+        "ww",
+        "arbeidsongeschik",
+        "wao",
+        "gemeentefonds",
+    ],
+    "EU-integratie–Nationalisme": [
+        # EU and international cooperation
+        "europees",
+        "europese",
+        " eu ",
+        "eu-",
+        "verdrag",
+        "intergouvernementeel",
+        "samenwerking",
+        "internationaal",
+        "navo",
+        "nato",
+        " vn ",
+        "vn-",
+        "sancties",
+        "israël",
+        "vluchteling",
+        "asiel",
+        "soevereiniteit",
+        "nationaal",
+    ],
+    "Populistisch–Institutioneel": [
+        # Populist/nationalist themes
+        "terugsturen",
+        "syrië",
+        "syrier",
+        "grenzen dicht",
+        "remigratie",
+        "eigen volk",
+        "nederland eerst",
+        "corona",
+        "vaccin",
+        "ivermectine",
+        "hydroxychloroquine",
+        "complot",
+        "deep state",
+        "establishment",
+        "elite",
+        "herstelbetaling",
+        "excuses",
+    ],
+    "Progressief–Conservatief": [
+        # environment
+        "klimaat",
+        "stikstof",
+        "duurzaam",
+        "duurzaamheid",
+        "co2",
+        "energietransitie",
+        "biodiversiteit",
+        # social
+        "euthanasie",
+        "abortus",
+        "lgbtq",
+        "transgender",
+        "diversiteit",
+        "traditi",
+        "gezin",
+        "religie",
+        "geloof",
+    ],
+}
+
+# Pre-compiled regexes for keyword matching. We escape keywords but do NOT add
+# word-boundaries because some keywords intentionally match substrings
+# (e.g. 'traditi' matching 'tradities'). re.IGNORECASE makes lowercasing
+# unnecessary during matching.
+_KEYWORD_REGEXES: Dict[str, "re.Pattern[str]"] = {
+    cat: re.compile(
+        "|".join(re.escape(kw.strip()) for kw in kws),
+        re.IGNORECASE,
+    )
+    for cat, kws in _KEYWORDS.items()
+}
+
+
+def _classify_from_titles(titles: List[str]) -> Tuple[Optional[str], float]:
+    """Classify a list of motion titles into an axis category using keyword matching.
+
+    Returns (category_label, confidence) where confidence = fraction of titles
+    containing at least one keyword from the winning category.
+    Returns (None, confidence) if confidence is below _KEYWORD_THRESHOLD.
+    """
+    if not titles:
+        return None, 0.0
+
+    counts: Dict[str, int] = {cat: 0 for cat in _KEYWORDS}
+    for title in titles:
+        for cat, rx in _KEYWORD_REGEXES.items():
+            if rx.search(title):
+                counts[cat] += 1
+
+    # Determine the best category, but be deterministic on ties: if more than
+    # one category has the top count, return None to indicate ambiguity.
+    best_count = max(counts.values())
+    best_cats = [cat for cat, cnt in counts.items() if cnt == best_count]
+    confidence = best_count / len(titles)
+
+    if len(best_cats) != 1 or confidence < _KEYWORD_THRESHOLD:
+        return None, confidence
+
+    return best_cats[0], confidence
+
+
+def _load_motion_vectors(db_path: str, window_id: str) -> Dict[int, np.ndarray]:
+    """Load SVD motion vectors for a given window from DuckDB.
+
+    Returns {motion_id: vector_array}. Returns {} on any error.
+    """
+    try:
+        import duckdb
+
+        conn = duckdb.connect(db_path, read_only=True)
+        try:
+            rows = conn.execute(
+                "SELECT entity_id, vector FROM svd_vectors "
+                "WHERE entity_type = 'motion' AND window_id = ?",
+                [window_id],
+            ).fetchall()
+        finally:
+            conn.close()
+        result: Dict[int, np.ndarray] = {}
+        for entity_id, vector_raw in rows:
+            try:
+                mid = int(entity_id)
+                vec = np.array(json.loads(vector_raw), dtype=float)
+                result[mid] = vec
+            except Exception:
+                continue
+        return result
+    except Exception as exc:
+        _logger.debug("Failed to load motion vectors for window %s: %s", window_id, exc)
+        return {}
+
+
+def _project_motions(
+    motion_vecs: Dict[int, np.ndarray],
+    x_axis: np.ndarray,
+    y_axis: np.ndarray,
+    global_mean: np.ndarray,
+) -> Dict[int, Tuple[float, float]]:
+    """Project motion vectors onto the PCA axes after centering by global_mean.
+
+    Returns {motion_id: (x_score, y_score)}.
+    """
+    try:
+        projections: Dict[int, Tuple[float, float]] = {}
+        for mid, vec in motion_vecs.items():
+            try:
+                centered = vec - global_mean
+                x_score = float(np.dot(centered, x_axis))
+                y_score = float(np.dot(centered, y_axis))
+                projections[mid] = (x_score, y_score)
+            except Exception:
+                continue
+        return projections
+    except Exception as exc:
+        _logger.debug("Failed to project motions: %s", exc)
+        return {}
+
+
+def _top_motion_ids(
+    projections: Dict[int, Tuple[float, float]],
+    axis: str,
+    n: int = 5,
+) -> Dict[str, List[int]]:
+    """Return the top-n motion IDs at each pole of the given axis.
+
+    axis: 'x' or 'y'
+    Returns {'+': [motion_ids], '-': [motion_ids]} (highest positive first,
+    most negative first in the '-' list).
+    """
+    try:
+        if axis not in ("x", "y"):
+            raise ValueError("axis must be 'x' or 'y'")
+        idx = 0 if axis == "x" else 1
+        sorted_ids = sorted(projections, key=lambda mid: projections[mid][idx])
+        neg_ids = sorted_ids[:n]
+        pos_ids = sorted_ids[-n:][::-1]
+        return {"+": pos_ids, "-": neg_ids}
+    except Exception as exc:
+        _logger.debug("Failed to compute top_motion_ids: %s", exc)
+        return {"+": [], "-": []}
+
+
+def _fetch_motion_titles(
+    db_path: str,
+    motion_ids: List[int],
+) -> Dict[int, Tuple[str, str]]:
+    """Fetch (title, date) for a list of motion IDs from DuckDB.
+
+    Returns {motion_id: (title, date_str)}. Missing IDs are omitted.
+    Returns {} on any DB error.
+    """
+    if not motion_ids:
+        return {}
+    try:
+        import duckdb
+
+        placeholders = ", ".join("?" for _ in motion_ids)
+        conn = duckdb.connect(db_path, read_only=True)
+        try:
+            rows = conn.execute(
+                f"SELECT id, title, date FROM motions WHERE id IN ({placeholders})",
+                motion_ids,
+            ).fetchall()
+        finally:
+            conn.close()
+        return {int(row[0]): (str(row[1]), str(row[2])) for row in rows}
+    except Exception as exc:
+        _logger.debug("Failed to fetch motion titles: %s", exc)
+        return {}
+
+
+def _load_ideology(csv_path: Path) -> Dict[str, Dict[str, float]]:
+    """Load party ideology scores from CSV.
+
+    Returns {party_name: {"left_right": float, "progressive": float}}.
+    Returns {} on any error (caller should treat empty as 'skip classification').
+    """
+    global _ideology_cache
+    if _ideology_cache is not None:
+        return _ideology_cache
+    result: Dict[str, Dict[str, float]] = {}
+    try:
+        with open(csv_path, encoding="utf-8") as fh:
+            lines = fh.read().splitlines()
+        header = [h.strip() for h in lines[0].split(",")]
+        lr_idx = header.index("left_right")
+        pc_idx = header.index("progressive")
+        for line in lines[1:]:
+            if not line.strip():
+                continue
+            parts = [p.strip() for p in line.split(",")]
+            if len(parts) <= max(lr_idx, pc_idx):
+                continue
+            result[parts[0]] = {
+                "left_right": float(parts[lr_idx]),
+                "progressive": float(parts[pc_idx]),
+            }
+    except FileNotFoundError:
+        _logger.warning(
+            "party_ideologies.csv not found at %s — axis labels will be generic",
+            csv_path,
+        )
+        return {}
+    except Exception as exc:
+        _logger.warning("Failed to load party_ideologies.csv: %s", exc)
+        return {}
+    _ideology_cache = result
+    return result
+
+
+def _load_coalition(csv_path: Path) -> Dict[str, set]:
+    """Load coalition membership from CSV.
+
+    Returns {window_id: set_of_party_names}.
+    Returns {} on any error (coalition dimension will be skipped).
+    """
+    global _coalition_cache
+    if _coalition_cache is not None:
+        return _coalition_cache
+    result: Dict[str, set] = {}
+    try:
+        with open(csv_path, encoding="utf-8") as fh:
+            lines = fh.read().splitlines()
+        for line in lines[1:]:
+            if not line.strip():
+                continue
+            parts = [p.strip() for p in line.split(",")]
+            if len(parts) < 2:
+                continue
+            wid, party = parts[0], parts[1]
+            result.setdefault(wid, set()).add(party)
+    except FileNotFoundError:
+        _logger.warning(
+            "coalition_membership.csv not found at %s — coalition axis detection disabled",
+            csv_path,
+        )
+        return {}
+    except Exception as exc:
+        _logger.warning("Failed to load coalition_membership.csv: %s", exc)
+        return {}
+    _coalition_cache = result
+    return result
+
+
+def _window_year(window_id: str) -> Optional[str]:
+    """Extract year string from window_id.
+
+    Returns None for 'current_parliament'.
+    '2016' → '2016', '2016-Q3' → '2016'.
+    """
+    if window_id == "current_parliament":
+        return None
+    return window_id.split("-")[0]
+
+
+def _pearsonr(x: List[float], y: List[float]) -> float:
+    """Pearson r; returns 0.0 for degenerate input (< 3 points or zero variance)."""
+    if len(x) < 3:
+        return 0.0
+    xa = np.array(x, dtype=float)
+    ya = np.array(y, dtype=float)
+    if xa.std() < 1e-12 or ya.std() < 1e-12:
+        return 0.0
+    return float(np.corrcoef(xa, ya)[0, 1])
+
+
+def _assign_label(
+    r_lr: float,
+    r_co: float,
+    r_pc: float,
+    axis: str,
+) -> Tuple[str, str, float]:
+    """Assign label, interpretation and quality score for one axis.
+
+    Priority: left-right > coalition > progressive > fallback.
+    Returns (label, interpretation_string, quality_score).
+    """
+    orientation = "horizontale" if axis == "x" else "verticale"
+    _x_fallback, _y_fallback = get_fallback_labels()
+    fallback_label = _x_fallback if axis == "x" else _y_fallback
+    quality = max(abs(r_lr), abs(r_co), abs(r_pc))
+
+    if abs(r_lr) >= _THRESHOLD:
+        return (
+            _LABELS["lr"],
+            _INTERPRETATION_TEMPLATES["lr"].format(orientation=orientation),
+            quality,
+        )
+    if abs(r_co) >= _THRESHOLD:
+        return (
+            _LABELS["co"],
+            _INTERPRETATION_TEMPLATES["co"].format(orientation=orientation, r=r_co),
+            quality,
+        )
+    if abs(r_pc) >= _THRESHOLD:
+        return (
+            _LABELS["pc"],
+            _INTERPRETATION_TEMPLATES["pc"].format(orientation=orientation),
+            quality,
+        )
+    return (
+        fallback_label,
+        "",  # No interpretation for unclassified axes
+        quality,
+    )
+
+
+def classify_axes(
+    positions_by_window: Dict[str, Dict[str, Tuple[float, float]]],
+    axes: dict,
+    db_path: str,
+) -> dict:
+    """Classify compass axes using motion projection (primary) and ideology CSV (fallback).
+
+    Motion projection path:
+        - Requires axes["global_mean"], axes["x_axis"], axes["y_axis"].
+        - Loads motion SVD vectors per window, projects onto PCA axes,
+          ranks top 5+5 motions, applies keyword classifier -> label.
+
+    Fallback path (unchanged):
+        - Pearson-r against party_ideologies.csv (left_right, progressive).
+        - Pearson-r against coalition_membership.csv dummy.
+
+    Enriches axes with:
+        x_label, y_label           — global modal label across annual windows
+        x_quality, y_quality       — {window_id: float} max |r|
+        x_interpretation           — {window_id: str}
+        y_interpretation           — {window_id: str}
+        x_top_motions, y_top_motions — {window_id: {'+': [(title, date), ...], '-': [...]}}
+        x_label_confidence         — {window_id: float}
+        y_label_confidence         — {window_id: float}
+    """
+    data_dir = Path(db_path).parent
+    ideology = _load_ideology(data_dir / "party_ideologies.csv")
+    coalition = _load_coalition(data_dir / "coalition_membership.csv")
+
+    # Determine whether motion projection is possible.
+    global_mean = axes.get("global_mean")
+    x_axis_arr = np.array(axes.get("x_axis", []))
+    y_axis_arr = np.array(axes.get("y_axis", []))
+    motion_path_available = (
+        global_mean is not None
+        and x_axis_arr.ndim == 1
+        and x_axis_arr.size > 0
+        and y_axis_arr.size > 0
+    )
+
+    # If we have neither ideology reference data nor motion vectors available,
+    # there is nothing to classify. Previously an early-exit below could be
+    # shadowed by a nested helper definition causing classify_axes to return
+    # None. Ensure we return the original axes dict in this case.
+    if not ideology and not motion_path_available:
+        return axes
+
+    x_quality: Dict[str, float] = {}
+    y_quality: Dict[str, float] = {}
+    x_interpretation: Dict[str, str] = {}
+    y_interpretation: Dict[str, str] = {}
+    x_top_motions: Dict[str, Dict] = {}
+    y_top_motions: Dict[str, Dict] = {}
+    x_label_confidence: Dict[str, float] = {}
+    y_label_confidence: Dict[str, float] = {}
+    annual_x_labels: List[str] = []
+    annual_y_labels: List[str] = []
+
+    for wid, pos_dict in positions_by_window.items():
+        year = _window_year(wid)
+        is_annual = wid != "current_parliament" and "-" not in wid
+
+        # ── Ideology / coalition Pearson-r (unchanged logic) ──────────────────
+        x_lbl_fallback: Optional[str] = None
+        y_lbl_fallback: Optional[str] = None
+        x_q = 0.0
+        y_q = 0.0
+        x_int = ""
+        y_int = ""
+
+        if ideology:
+            parties = [p for p in pos_dict if p in ideology]
+            if len(parties) >= 5:
+                party_x = [pos_dict[p][0] for p in parties]
+                party_y = [pos_dict[p][1] for p in parties]
+                ref_lr = [ideology[p]["left_right"] for p in parties]
+                ref_pc = [ideology[p]["progressive"] for p in parties]
+
+                if year and coalition and year in coalition:
+                    gov_set = coalition[year]
+                    ref_co = [1.0 if p in gov_set else -1.0 for p in parties]
+                else:
+                    ref_co = [0.0] * len(parties)
+
+                r_lr_x = _pearsonr(party_x, ref_lr)
+                r_co_x = _pearsonr(party_x, ref_co)
+                r_pc_x = _pearsonr(party_x, ref_pc)
+                x_lbl_fallback, x_int, x_q = _assign_label(r_lr_x, r_co_x, r_pc_x, "x")
+
+                r_lr_y = _pearsonr(party_y, ref_lr)
+                r_co_y = _pearsonr(party_y, ref_co)
+                r_pc_y = _pearsonr(party_y, ref_pc)
+                y_lbl_fallback, y_int, y_q = _assign_label(r_lr_y, r_co_y, r_pc_y, "y")
+
+        # ── Motion projection (primary) ────────────────────────────────────────
+        x_lbl = x_lbl_fallback
+        y_lbl = y_lbl_fallback
+        x_conf = 0.0
+        y_conf = 0.0
+        x_tops: Dict[str, List] = {"+": [], "-": []}
+        y_tops: Dict[str, List] = {"+": [], "-": []}
+
+        if motion_path_available:
+            motion_vecs = _load_motion_vectors(db_path, wid)
+            if motion_vecs:
+                projections = _project_motions(
+                    motion_vecs, x_axis_arr, y_axis_arr, global_mean
+                )
+                x_ids = _top_motion_ids(projections, "x", n=5)
+                y_ids = _top_motion_ids(projections, "y", n=5)
+
+                all_x_ids = x_ids["+"] + x_ids["-"]
+                all_y_ids = y_ids["+"] + y_ids["-"]
+                titles_map = _fetch_motion_titles(
+                    db_path, list(set(all_x_ids + all_y_ids))
+                )
+
+                x_title_list = [
+                    titles_map[mid][0] for mid in all_x_ids if mid in titles_map
+                ]
+                y_title_list = [
+                    titles_map[mid][0] for mid in all_y_ids if mid in titles_map
+                ]
+
+                x_kw_lbl, x_conf = _classify_from_titles(x_title_list)
+                y_kw_lbl, y_conf = _classify_from_titles(y_title_list)
+
+                if x_kw_lbl is not None:
+                    x_lbl = x_kw_lbl
+                    if not x_int:
+                        tkey = _MOTION_LABEL_TEMPLATE_KEY.get(x_kw_lbl, "fallback")
+                        x_int = _INTERPRETATION_TEMPLATES[tkey].format(
+                            orientation="horizontale"
+                        )
+                if y_kw_lbl is not None:
+                    y_lbl = y_kw_lbl
+                    if not y_int:
+                        tkey = _MOTION_LABEL_TEMPLATE_KEY.get(y_kw_lbl, "fallback")
+                        y_int = _INTERPRETATION_TEMPLATES[tkey].format(
+                            orientation="verticale"
+                        )
+
+                # Build display lists: [(title, date), ...]
+                for pole, ids in x_ids.items():
+                    x_tops[pole] = [titles_map[mid] for mid in ids if mid in titles_map]
+                for pole, ids in y_ids.items():
+                    y_tops[pole] = [titles_map[mid] for mid in ids if mid in titles_map]
+
+        # ── Final label resolution ────────────────────────────────────────────
+        # If both motion and ideology paths produced nothing, use generic fallback.
+        _x_fallback, _y_fallback = get_fallback_labels()
+        if x_lbl is None:
+            x_lbl = _x_fallback
+            x_int = ""  # No interpretation for unclassified axes
+        if y_lbl is None:
+            y_lbl = _y_fallback
+            y_int = ""  # No interpretation for unclassified axes
+
+        x_quality[wid] = x_q
+        y_quality[wid] = y_q
+        x_interpretation[wid] = x_int
+        y_interpretation[wid] = y_int
+        x_top_motions[wid] = x_tops
+        y_top_motions[wid] = y_tops
+        x_label_confidence[wid] = x_conf
+        y_label_confidence[wid] = y_conf
+
+        if is_annual:
+            annual_x_labels.append(x_lbl)
+            annual_y_labels.append(y_lbl)
+
+    def _modal(labels: List[str], fallback: str) -> str:
+        if not labels:
+            return fallback
+        return Counter(labels).most_common(1)[0][0]
+
+    # Use the module-level display_label_for_modal defined above.
+
+    enriched = dict(axes)
+    # Resolve modal label across annual windows. If the modal label is the
+    # internal generic component name ("As 1"/"As 2" or legacy
+    # "Stempatroon As N"), prefer a conventional short semantic fallback so the
+    # UI doesn't display unhelpful "As N" strings to end users.
+    modal_x = _modal(annual_x_labels, "Links\u2013Rechts")
+    modal_y = _modal(annual_y_labels, "Progressief\u2013Conservatief")
+
+    enriched["x_label"] = display_label_for_modal(modal_x, "x")
+    enriched["y_label"] = display_label_for_modal(modal_y, "y")
+    enriched["x_quality"] = x_quality
+    enriched["y_quality"] = y_quality
+    enriched["x_interpretation"] = x_interpretation
+    enriched["y_interpretation"] = y_interpretation
+    enriched["x_top_motions"] = x_top_motions
+    enriched["y_top_motions"] = y_top_motions
+    enriched["x_label_confidence"] = x_label_confidence
+    enriched["y_label_confidence"] = y_label_confidence
+    return enriched

analysis/clustering.py

@@ -11,7 +11,13 @@ import logging
 from typing import Dict, List, Optional, Tuple
 
 import numpy as np
-import duckdb
+
+try:
+    import duckdb
+except (
+    Exception
+):  # pragma: no cover - import-time guard for environments without duckdb
+    duckdb = None  # type: ignore
 
 _logger = logging.getLogger(__name__)
 

analysis/config.py

@@ -0,0 +1,331 @@
+"""Configuration constants for the parliamentary explorer.
+
+This module contains all constant definitions used across the explorer.
+It is intentionally free of Streamlit and DuckDB dependencies.
+"""
+
+from __future__ import annotations
+
+from typing import Dict
+
+__all__ = [
+    "PARTY_COLOURS",
+    "SVD_THEMES",
+    "KNOWN_MAJOR_PARTIES",
+    "CURRENT_PARLIAMENT_PARTIES",
+    "_PARTY_NORMALIZE",
+    "CANONICAL_RIGHT",
+    "CANONICAL_LEFT",
+]
+
+CANONICAL_RIGHT: frozenset[str] = frozenset(
+    {
+        "PVV",
+        "FVD",
+        "JA21",
+        "SGP",
+    }
+)
+
+CANONICAL_LEFT: frozenset[str] = frozenset(
+    {
+        "SP",
+        "PvdA",
+        "GL",
+        "GroenLinks",
+        "GroenLinks-PvdA",
+        "DENK",
+        "PvdD",
+        "Volt",
+    }
+)
+
+PARTY_COLOURS: Dict[str, str] = {
+    "VVD": "#1E73BE",
+    "PVV": "#002366",
+    "D66": "#00A36C",
+    "CDA": "#4CAF50",
+    "SP": "#E53935",
+    "PvdA": "#D32F2F",
+    "GroenLinks": "#388E3C",
+    "GroenLinks-PvdA": "#2E7D32",
+    "CU": "#0288D1",
+    "SGP": "#F4511E",
+    "PvdD": "#43A047",
+    "FVD": "#6A1B9A",
+    "JA21": "#7B1FA2",
+    "BBB": "#8D6E63",
+    "NSC": "#FF8F00",
+    "Nieuw Sociaal Contract": "#FF8F00",
+    "DENK": "#00897B",
+    "50PLUS": "#7E57C2",
+    "Volt": "#572AB7",
+    "ChristenUnie": "#0288D1",
+    "Unknown": "#9E9E9E",
+}
+
+SVD_THEMES: dict[int, dict[str, str]] = {
+    1: {
+        "label": "Fiscaal-economisch beleid versus sociaal welzijn en internationale rechten",
+        "explanation": (
+            "Deze as scheidt fiscaal-economisch beleid van sociaal welzijn en internationale solidariteit. "
+            "Aan de positieve kant staan moties over dijkvervanging, medische bijscholing, gaswinning op land, "
+            "landbouwsubsidies en fiscale verlichting. "
+            "Aan de negatieve kant staan moties over huurprijsbeheersing, boycot van defensiebedrijven, "
+            "beëindiging van militaire verdragen, antipersoneelslandmijnen en zorgbuurthuizen. "
+            "Deze as weerspiegelt de spanning tussen financieel-economische prioriteiten en sociaal-internationaal beleid."
+        ),
+        "positive_pole": "Fiscaal-economisch: dijkvervanging, landbouwsubsidies, gaswinning, fiscale verlichting",
+        "negative_pole": "Sociaal welzijn en internationale rechten: huurbeheersing, defensieboycot, zorg, landmijnverbod",
+        "flip": False,
+    },
+    2: {
+        "label": "Nationalistische versus multilateralistische oriëntatie",
+        "explanation": (
+            "Deze as meet een onafhankelijke culturele dimensie: nationalistisch-populistisch "
+            "tegenover kosmopolitisch-mainstream. Aan de positieve kant staan PVV en FVD. "
+            "Aan de negatieve kant staan Volt, GroenLinks-PvdA, DENK en SP. "
+            "Deze as is onafhankelijk van links-rechts (as 1) en scheidt partijen "
+            "op hun houding tegenover nationale identiteit, EU-samenwerking en de "
+            "etnisch-culturele dimensie."
+        ),
+        "positive_pole": "Nationalistisch/populistisch — PVV, FVD: nationale identiteit en soevereiniteit",
+        "negative_pole": "Kosmopolitisch/mainstream — Volt, GL-PvdA, DENK, SP: EU en internationale samenwerking",
+        "flip": False,
+    },
+    3: {
+        "label": "Verzorgingsstaat versus defensie en nationale veiligheid",
+        "explanation": (
+            "Deze as weerspiegelt de spanning tussen staatsingrijpen en marktliberalisme, "
+            "aangescherpt door de kabinetscrisis van 2025. Aan de positieve kant staan moties "
+            "die bezuinigingen op zorg en het gemeentefonds willen terugdraaien, winstuitkeringen "
+            "in de zorg verbieden en publieke controle over ziekenhuisfusies eisen. SP, PvdD, "
+            "GroenLinks-PvdA stemmen hier gelijk — ondanks hun tegengestelde PC1-posities. "
+            "Aan de negatieve kant staan moties "
+            "over marktwerking in de zorg, fiscale bedrijfsopvolgingsfaciliteiten (VVD), "
+            "doorgaan met besturen ondanks de kabinetscrisis (VVD/BBB) en defensie-"
+            "uitgaven van 3,5% bbp."
+        ),
+        "positive_pole": "Pro-verzorgingsstaat: SP, PvdD, GroenLinks-PvdA (anti-bezuinigingen)",
+        "negative_pole": "Marktliberaal en fiscaal conservatief: VVD, D66, CDA, SGP, BBB",
+        "flip": True,
+    },
+    4: {
+        "label": "Actieve internationale betrokkenheid versus terughoudendheid",
+        "explanation": (
+            "Deze as scheidt actieve internationale betrokkenheid van terughoudendheid of terugtrekking. "
+            "Aan de positieve kant staan moties over bilaterale en Europese samenwerking: partnerschappen met Australië, "
+            "actieve vaderbetrokkenheid, kennisuitwisseling en coördinatie via internationale gremia. "
+            "Aan de negatieve kant staan moties over verlaten van de WHO, beperking van migratiesaldo, "
+            "gezinsbeleid en asielrestricties. "
+            "Deze as is indicatief — de spreiding van partijen is breed."
+        ),
+        "positive_pole": "Actieve internationale betrokkenheid: bilaterale samenwerking, kennisuitwisseling, multilaterale coördinatie",
+        "negative_pole": "Terughoudendheid en restricties: WHO-verlating, migratielimieten, binnenlands gericht beleid",
+        "flip": False,
+    },
+    5: {
+        "label": "Pragmatische financiële ondersteuning versus progressieve individuele rechten",
+        "explanation": (
+            "Deze as scheidt pragmatische financiële en structurele ondersteuning van progressieve individuele rechten. "
+            "Aan de positieve kant staan moties over een vrijgesteld minimumbudget voor infrastructurele werken, "
+            "maatschappelijke diensttijd voor kwetsbare jongeren, verkorting van de WW alleen met concrete "
+            "ondersteuningsmaatregelen, en vrijwaring van kindertoeslagen. "
+            "Aan de negatieve kant staan moties over erkenning van meerouderschap, "
+            "wettelijke kwaliteitseisen aan zwemlessen, een nationaal coördinator tegen buitenlandse beïnvloeding, "
+            "en vastlegging van abortusrecht in het EU-Handvest. "
+            "Deze as weerspiegelt de spanning tussen financiële prikkels en individuele rechtenbescherming."
+        ),
+        "positive_pole": "Pragmatische financiële ondersteuning: budgetvrijwaring, diensttijd, WW-hervorming, kindertoeslagen",
+        "negative_pole": "Progressieve individuele rechten: meerouderschap, abortusrecht, zwemveiligheid, buitenlandse beïnvloeding",
+        "flip": False,
+    },
+    6: {
+        "label": "Fossiele brandstoffen en financiële prikkels versus klimaatbeleid en internationale rechten",
+        "explanation": (
+            "Deze as scheidt fossiele brandstoffen en financiële marktprikkels van klimaatbeleid en internationale rechten. "
+            "Aan de positieve kant staan moties over lng-capaciteit als alternatief voor gaswinning, "
+            "kernenergie als volwaardig onderdeel van energiebeleid, vermogenswinstbelasting en beperkte "
+            "overheidsuitgaven. "
+            "Aan de negatieve kant staan moties over het uitsluiten van de fossiele industrie van klimaatconferenties, "
+            "veroordeling van aanvallen op Libanon, sancties tegen internationale conflicten, "
+            "en structureel overleg met moslimgemeenschappen. "
+            "Deze as weerspiegelt de spanning tussen economisch-fiscale prioriteiten en klimaat/internationale solidariteit."
+        ),
+        "positive_pole": "Fossiel en financieel: lng-capaciteit, kernenergie, vermogenswinstbelasting, bezuinigingen",
+        "negative_pole": "Klimaat en internationale rechten: fossiele industrie uitsluiten, sancties, Libanon, gemeenschappen",
+        "flip": False,
+    },
+    7: {
+        "label": "Praktisch-bestuurlijk versus idealistisch-proceduraal",
+        "explanation": (
+            "Een residuele as die overwegend beleidsdossiers uit 2024 (vorige parlementaire "
+            "periode) omvat. De scores zijn smal (max ~11 punten) en de partijcombinaties "
+            "ideologisch divers — dit label is indicatief. Aan de positieve kant staan "
+            "pragmatische bestuursmoties: een compleet kostenoverzicht van producten van eigen "
+            "bodem, papieren schoolboeken voor basisvaardigheden, een invoeringstoets voor het "
+            "minimumloon en de A2-snelwegplanning. ChristenUnie, Volt, DENK en SP scoren "
+            "positief. Aan de negatieve kant staan meer ideologisch geladen moties: een "
+            "landelijk stookverbod (PvdD), het strafbaar stellen van verbranding van religieuze "
+            "geschriften (DENK), chroom-6 schadevergoedingen en tegenhouden van nieuwe "
+            "gaswinning. GroenLinks-PvdA, VVD, FVD en JA21 scoren negatief."
+        ),
+        "positive_pole": "Praktisch-bestuurlijk: ChristenUnie, Volt, SGP, DENK, SP",
+        "negative_pole": "Ideologisch-principieel: GroenLinks-PvdA, VVD, FVD, JA21",
+        "flip": True,
+    },
+    8: {
+        "label": "Europese defensiesamenwerking versus binnenlands sociaaleconomisch beleid",
+        "explanation": (
+            "Deze as scheidt Europese defensiesamenwerking van binnenlands sociaaleconomisch beleid. "
+            "Aan de positieve kant staan moties over militaire mobiliteit in EU- en NAVO-verband, "
+            "een Europees onderzoeksinstituut voor defensie, en concrete stappen voor 35% defensie-uitgaven. "
+            "Aan de negatieve kant staan moties over toeslagenaffaire-herstel, ontslagrecht, "
+            "coronastrategie en bestuurlijke instructieregels. "
+            "Deze as is indicatief — de spreiding van partijen is breed en de thematische diversiteit is groot."
+        ),
+        "positive_pole": "Europese defensiesamenwerking: NAVO-militaire mobiliteit, Europees defensie-instituut, defensie-uitgaven",
+        "negative_pole": "Binnenlands beleid: toeslagen, ontslagrecht, coronastrategie, administratieve lasten",
+        "flip": False,
+    },
+    9: {
+        "label": "Concreet-bestuurlijke versus systemische hervorming",
+        "explanation": (
+            "Deze as scheidt concreet-bestuurlijke oplossingen van systemische hervorming. "
+            "Aan de positieve kant staan moties over naleving van financiële verhoudingswetten voor gemeenten, "
+            "beperking van arbeidsmigratie, een nieuwe tandartsopleiding in Rotterdam, "
+            "en oplossingen voor milieuproblemen op Bonaire. "
+            "Aan de negatieve kant staan moties over een moratorium op geitenstallen, "
+            "een verbod op gokadvertenties, gronden voor voorlopige hechtenis, "
+            "een leegstandbelasting en end-to-end-encryptie. "
+            "Deze as is indicatief — de scores zijn smal en ideologisch divers."
+        ),
+        "positive_pole": "Concreet-bestuurlijk: financiële verhoudingswet, arbeidsmigratie, tandartsopleiding, Bonaire",
+        "negative_pole": "Systemische hervorming: geitenstallen-moratorium, gokverbod, leegstandbelasting, encryptie",
+        "flip": False,
+    },
+    10: {
+        "label": "Bescherming van burgers versus overheidsregulering",
+        "explanation": (
+            "Deze as scheidt bescherming van burgers van overheidsregulering en handhaving. "
+            "Aan de positieve kant staan moties over minder tijdsintensieve schoolinspecties, "
+            "het recht van toeslagenouders op hun persoonlijk dossier, behoud van tegemoetkomingen "
+            "voor arbeidsongeschikten, integratie die geldt voor nieuwkomers (niet voor Nederlanders), "
+            "en verlaging van de leeftijdsdrempel voor kindgesprekken. "
+            "Aan de negatieve kant staan moties over een aangifteplicht voor scholen bij "
+            "veiligheidsincidenten, rookverboden in auto's met kinderen, "
+            "braakliggende landbouwgrond en verhoogd beloningsgeld voor tipgevers. "
+            "Deze as is indicatief — de scores zijn smal en de partijcombinaties divers."
+        ),
+        "positive_pole": "Bescherming van burgers: minder inspecties, toegang tot dossiers, behoud toeslagen, kindleeftijd",
+        "negative_pole": "Overheidsregulering: aangifteplicht scholen, rookverbod, braakliggende grond, tipgeversbeloning",
+        "flip": True,
+    },
+}
+
+KNOWN_MAJOR_PARTIES = [
+    "VVD",
+    "PVV",
+    "D66",
+    "GroenLinks-PvdA",
+    "GroenLinks",
+    "PvdA",
+    "CDA",
+    "SP",
+    "NSC",
+    "CU",
+    "BBB",
+]
+
+CURRENT_PARLIAMENT_PARTIES: frozenset[str] = frozenset(
+    {
+        "PVV",
+        "VVD",
+        "NSC",
+        "BBB",
+        "D66",
+        "GroenLinks-PvdA",
+        "CDA",
+        "SP",
+        "ChristenUnie",
+        "SGP",
+        "Volt",
+        "DENK",
+        "PvdD",
+        "JA21",
+        "FVD",
+    }
+)
+
+_PARTY_NORMALIZE: dict[str, str] = {
+    "Nieuw Sociaal Contract": "NSC",
+    "CU": "ChristenUnie",
+    "GL": "GroenLinks-PvdA",
+    "GroenLinks": "GroenLinks-PvdA",
+    "PvdA": "GroenLinks-PvdA",
+    "Gündoğan": "Volt",
+    "Lid Keijzer": "BBB",
+    "Groep Markuszower": "PVV",
+}
+
+# ---------------------------------------------------------------------------
+# Application configuration (migrated from root config.py)
+# ---------------------------------------------------------------------------
+
+import os
+from dataclasses import dataclass
+
+
+@dataclass
+class Config:
+    # Database settings
+    DATABASE_PATH = "data/motions.db"
+
+    # API settings
+    TWEEDE_KAMER_ODATA_API = "https://gegevensmagazijn.tweedekamer.nl/OData/v4/2.0"
+    API_TIMEOUT = 30
+    API_BATCH_SIZE = 250
+    API_MAX_LIMIT = 250
+
+    # AI settings
+    OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+    OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+    QWEN_MODEL = "qwen/qwen-2.5-72b-instruct"
+
+    # App settings
+    DEFAULT_MOTION_COUNT = 10
+    DEFAULT_WINNING_MARGIN_MIN = 0
+    DEFAULT_WINNING_MARGIN_MAX = 100
+    SESSION_TIMEOUT_DAYS = 30
+
+    # Policy areas
+    POLICY_AREAS = [
+        "Alle",
+        "Economie",
+        "Klimaat",
+        "Immigratie",
+        "Zorg",
+        "Onderwijs",
+        "Defensie",
+        "Sociale Zaken",
+        "Algemeen",
+    ]
+
+    # Scraper defaults
+    BASE_URL = "https://www.tweedekamer.nl/zoeken/zoekresultaten"
+    SCRAPING_DELAY = int(os.getenv("SCRAPING_DELAY", "5"))
+
+
+config = Config()
+
+__all__ = [
+    "PARTY_COLOURS",
+    "SVD_THEMES",
+    "KNOWN_MAJOR_PARTIES",
+    "CURRENT_PARLIAMENT_PARTIES",
+    "_PARTY_NORMALIZE",
+    "CANONICAL_RIGHT",
+    "CANONICAL_LEFT",
+    "Config",
+    "config",
+]

analysis/explorer_data.py

@@ -0,0 +1,767 @@
+"""Data loading functions for the parliamentary explorer.
+
+This module contains all data loading functions extracted from explorer.py.
+It is intentionally free of Streamlit side-effects to be easy to unit test.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Dict, List, Set, Tuple
+
+try:
+    import duckdb
+except (
+    Exception
+):  # pragma: no cover - allow lightweight import without duckdb installed
+    duckdb = None  # type: ignore
+import numpy as np
+import pandas as pd
+
+from analysis.config import CURRENT_PARLIAMENT_PARTIES, _PARTY_NORMALIZE
+
+__all__ = [
+    "get_available_windows",
+    "get_uniform_dim_windows",
+    "load_positions",
+    "load_party_map",
+    "load_active_mps",
+    "load_mp_vectors_by_window",
+    "load_mp_vectors_by_party",
+    "load_mp_vectors_by_party_for_window",
+    "load_party_axis_scores",
+    "load_party_axis_scores_for_window",
+    "load_party_scores_all_windows",
+    "load_party_scores_all_windows_aligned",
+    "load_party_mp_vectors",
+    "build_window_party_scores",
+    "load_motions_df",
+    "query_similar",
+    "compute_party_axis_scores",
+    "get_aligned_party_scores",
+    "compute_party_discipline",
+    "_get_aligned_trajectory_scores",
+]
+
+logger = logging.getLogger(__name__)
+
+_WINDOW_SQL = """
+    SELECT DISTINCT window_id FROM svd_vectors ORDER BY window_id
+"""
+
+_UNIFORM_DIM_SQL = """
+    WITH vec_dims AS (
+        SELECT window_id, json_array_length(vector) AS dim
+        FROM svd_vectors
+        WHERE entity_type = 'mp'
+    ),
+    window_dim_counts AS (
+        SELECT window_id, dim, COUNT(*) AS cnt
+        FROM vec_dims
+        GROUP BY window_id, dim
+    ),
+    dominant AS (
+        SELECT DISTINCT ON (window_id) window_id, dim, cnt
+        FROM window_dim_counts
+        ORDER BY window_id, cnt DESC, dim DESC
+    )
+    SELECT window_id
+    FROM dominant
+    WHERE dim >= 25 AND cnt >= 10
+      AND window_id NOT LIKE '%-Q%'
+    ORDER BY window_id
+"""
+
+
+def get_available_windows(db_path: str) -> List[str]:
+    """Return sorted list of distinct window_ids from svd_vectors."""
+    con = duckdb.connect(database=db_path, read_only=True)
+    try:
+        rows = con.execute(_WINDOW_SQL).fetchall()
+        return [r[0] for r in rows]
+    except Exception:
+        logger.exception("Failed to query available windows")
+        return []
+    finally:
+        con.close()
+
+
+def get_uniform_dim_windows(db_path: str) -> List[str]:
+    """Return only windows whose dominant MP-vector dimension is >= 25.
+
+    Some windows contain a mix of vector lengths due to multiple pipeline runs
+    (e.g. 2016 has both dim=1 and dim=50 rows). We find the most common dimension
+    per window and include only windows where that dominant dim >= 25.
+    Windows with too few dim-25+ entities (< 10) are also excluded to avoid
+    degenerate PCA inputs.
+    """
+    con = duckdb.connect(database=db_path, read_only=True)
+    try:
+        rows = con.execute(_UNIFORM_DIM_SQL).fetchall()
+        return [r[0] for r in rows]
+    except Exception:
+        logger.exception("Failed to query uniform-dim windows")
+        return []
+    finally:
+        con.close()
+
+
+def load_party_map(db_path: str) -> Dict[str, str]:
+    """Return {mp_name: party} mapping, with party names normalised to abbreviations."""
+    try:
+        con = duckdb.connect(database=db_path, read_only=True)
+        rows = con.execute(
+            "SELECT mp_name, party FROM mp_metadata WHERE party IS NOT NULL"
+        ).fetchall()
+        con.close()
+        return {
+            mp: _PARTY_NORMALIZE.get(party, party) for mp, party in rows if mp and party
+        }
+    except Exception:
+        logger.exception("Failed to load party map")
+        return {}
+
+
+def load_active_mps(db_path: str) -> Set[str]:
+    """Return the set of mp_name values that are currently seated in parliament.
+
+    An MP is considered active if their mp_metadata row has tot_en_met IS NULL,
+    meaning they have no recorded end date for their current seat.
+    """
+    try:
+        con = duckdb.connect(database=db_path, read_only=True)
+        rows = con.execute(
+            "SELECT mp_name FROM mp_metadata WHERE tot_en_met IS NULL"
+        ).fetchall()
+        con.close()
+        return {r[0] for r in rows if r[0]}
+    except Exception:
+        logger.exception("Failed to load active MPs")
+        return set()
+
+
+def load_party_axis_scores(db_path: str) -> Dict[str, List[float]]:
+    """Return party scores for all windows (non-aligned).
+
+    Returns dict mapping party_abbrev -> list of axis scores, one per window.
+    Computed as the mean of individual MP vectors per party.
+    """
+    try:
+        return compute_party_axis_scores(load_mp_vectors_by_party(db_path))
+    except Exception:
+        logger.exception("Failed to load party axis scores")
+        return {}
+
+
+def load_party_axis_scores_for_window(
+    db_path: str, window: str
+) -> Dict[str, List[float]]:
+    """Return party scores for a specific window.
+
+    Computed as the mean of individual MP vectors per party for the window.
+    """
+    try:
+        return compute_party_axis_scores(
+            load_mp_vectors_by_party_for_window(db_path, window)
+        )
+    except Exception:
+        logger.exception("Failed to load party axis scores for window %s", window)
+        return {}
+
+
+def load_party_scores_all_windows(db_path: str) -> Dict[str, List[List[float]]]:
+    """Return party scores across all windows (non-aligned)."""
+    try:
+        con = duckdb.connect(database=db_path, read_only=True)
+        table_exists = con.execute(
+            "SELECT COUNT(*) FROM information_schema.tables WHERE table_name = 'party_axis_scores'"
+        ).fetchone()[0]
+        if table_exists:
+            rows = con.execute(
+                """
+                SELECT party_abbrev, window_id, x_axis, y_axis
+                FROM party_axis_scores
+                ORDER BY party_abbrev, window_id
+                """
+            ).fetchall()
+            con.close()
+
+            scores: Dict[str, List[List[float]]] = {}
+            current_party = None
+            for party, window, x, y in rows:
+                if party != current_party:
+                    scores[party] = []
+                    current_party = party
+                if x is not None and y is not None:
+                    scores[party].append([x, y])
+                else:
+                    scores[party].append([0.0, 0.0])
+            return scores
+        con.close()
+    except Exception:
+        logger.exception("Failed to load party scores all windows from table")
+
+    # Fallback: compute from positions when table does not exist
+    try:
+        positions_by_window, _ = load_positions(db_path, "annual")
+        _party_map = load_party_map(db_path)
+        scores: Dict[str, List[List[float]]] = {}
+        for window, window_pos in positions_by_window.items():
+            party_coords: Dict[str, List[Tuple[float, float]]] = {}
+            for mp_name, (x, y) in window_pos.items():
+                party = _party_map.get(
+                    mp_name, _party_map.get(mp_name.split("(")[0].strip(), None)
+                )
+                if party:
+                    party_coords.setdefault(party, []).append((x, y))
+            for party, coords in party_coords.items():
+                if coords:
+                    mean_x = float(np.mean([c[0] for c in coords]))
+                    mean_y = float(np.mean([c[1] for c in coords]))
+                    scores.setdefault(party, []).append([mean_x, mean_y])
+        return scores
+    except Exception:
+        logger.exception("Failed to compute party scores all windows from positions")
+        return {}
+
+
+def load_party_scores_all_windows_aligned(
+    db_path: str,
+) -> Dict[str, List[List[float]]]:
+    """Return party scores across all windows (Procrustes-aligned)."""
+    try:
+        con = duckdb.connect(database=db_path, read_only=True)
+        table_exists = con.execute(
+            "SELECT COUNT(*) FROM information_schema.tables WHERE table_name = 'party_axis_scores'"
+        ).fetchone()[0]
+        if table_exists:
+            rows = con.execute(
+                """
+                SELECT party_abbrev, window_id, x_axis_aligned, y_axis_aligned
+                FROM party_axis_scores
+                ORDER BY party_abbrev, window_id
+                """
+            ).fetchall()
+            con.close()
+
+            scores: Dict[str, List[List[float]]] = {}
+            current_party = None
+            for party, window, x, y in rows:
+                if party != current_party:
+                    scores[party] = []
+                    current_party = party
+                if x is not None and y is not None:
+                    scores[party].append([x, y])
+                else:
+                    scores[party].append([0.0, 0.0])
+            return scores
+        con.close()
+    except Exception:
+        logger.exception("Failed to load aligned party scores all windows from table")
+
+    # Fallback: compute from positions when table does not exist
+    try:
+        positions_by_window, _ = load_positions(db_path, "annual")
+        _party_map = load_party_map(db_path)
+        scores: Dict[str, List[List[float]]] = {}
+        for window, window_pos in positions_by_window.items():
+            party_coords: Dict[str, List[Tuple[float, float]]] = {}
+            for mp_name, (x, y) in window_pos.items():
+                party = _party_map.get(
+                    mp_name, _party_map.get(mp_name.split("(")[0].strip(), None)
+                )
+                if party:
+                    party_coords.setdefault(party, []).append((x, y))
+            for party, coords in party_coords.items():
+                if coords:
+                    mean_x = float(np.mean([c[0] for c in coords]))
+                    mean_y = float(np.mean([c[1] for c in coords]))
+                    scores.setdefault(party, []).append([mean_x, mean_y])
+        return scores
+    except Exception:
+        logger.exception("Failed to compute aligned party scores all windows from positions")
+        return {}
+
+
+def build_window_party_scores(
+    scores_by_party: Dict[str, List[List[float]]],
+    window_idx: int,
+) -> Dict[str, List[float]]:
+    """Extract scores for one window as {party: [x, y]} for compute_flip_direction.
+
+    Args:
+        scores_by_party: Output of load_party_scores_all_windows_aligned —
+            {party: [[x, y], [x, y], ...]} per window.
+        window_idx: Zero-based index of the window to extract.
+
+    Returns:
+        {party: [x, y]} for the given window. Returns empty dict if
+        window_idx is out of range.
+    """
+    if window_idx < 0:
+        return {}
+    result: Dict[str, List[float]] = {}
+    for party, window_scores in scores_by_party.items():
+        if window_idx < len(window_scores):
+            result[party] = window_scores[window_idx]
+    return result
+
+
+def load_party_mp_vectors(db_path: str) -> Dict[str, List[np.ndarray]]:
+    """Load individual MP SVD vectors grouped by party.
+
+    Returns {party_name: [np.ndarray(50,), ...]} — one array per MP.
+    """
+    con = duckdb.connect(database=db_path, read_only=True)
+    try:
+        meta_rows = con.execute(
+            "SELECT mp_name, party FROM mp_metadata "
+            "WHERE van >= '2023-11-22' OR tot_en_met IS NULL OR tot_en_met >= '2023-11-22' "
+            "ORDER BY van ASC"
+        ).fetchall()
+        mp_party: Dict[str, str] = {}
+        for mp_name, party in meta_rows:
+            if mp_name and party:
+                mp_party[mp_name] = _PARTY_NORMALIZE.get(party, party)
+
+        rows = con.execute(
+            "SELECT entity_id, vector FROM svd_vectors "
+            "WHERE entity_type = 'mp' AND window_id = 'current_parliament'"
+        ).fetchall()
+
+        vectors_by_party: Dict[str, List[np.ndarray]] = {}
+        for entity_id, vector_json in rows:
+            if entity_id in mp_party:
+                party = mp_party[entity_id]
+                if party not in vectors_by_party:
+                    vectors_by_party[party] = []
+                vectors_by_party[party].append(np.array(vector_json))
+
+        return vectors_by_party
+    except Exception:
+        logger.exception("Failed to load party MP vectors")
+        return {}
+    finally:
+        con.close()
+
+
+def load_scree_data(db_path: str) -> List[float]:
+    """Load scree plot data (explained variance) for current_parliament.
+
+    First tries to read the cached metadata row from svd_vectors.
+    Falls back to on-the-fly computation via compute_svd_spectrum for
+    backward compatibility with databases that haven't stored it yet.
+    """
+    try:
+        con = duckdb.connect(database=db_path, read_only=True)
+        row = con.execute(
+            """
+            SELECT vector FROM svd_vectors
+            WHERE window_id = 'current_parliament'
+              AND entity_type = 'metadata'
+              AND entity_id = 'explained_variance'
+            LIMIT 1
+            """
+        ).fetchone()
+        con.close()
+
+        if row and row[0]:
+            import json
+
+            return json.loads(row[0])
+
+        # Fallback: compute dynamically for backward compatibility
+        from analysis.political_axis import compute_svd_spectrum
+
+        return compute_svd_spectrum(db_path)
+    except Exception:
+        logger.exception("Failed to load scree data")
+        return []
+
+
+def load_motions_df(db_path: str) -> pd.DataFrame:
+    """Load the full motions table as a pandas DataFrame (read-only)."""
+    try:
+        con = duckdb.connect(database=db_path, read_only=True)
+        df = con.execute(
+            """
+            SELECT id, title, description, date, policy_area,
+                   voting_results, layman_explanation,
+                   winning_margin, controversy_score, url
+            FROM motions
+            """
+        ).fetchdf()
+        con.close()
+        df["date"] = pd.to_datetime(df["date"], errors="coerce")
+        df["year"] = df["date"].dt.year
+        return df
+    except Exception:
+        logger.exception("Failed to load motions DataFrame")
+        return pd.DataFrame()
+
+
+def load_mp_vectors_by_window(db_path: str, window: str) -> Dict[str, np.ndarray]:
+    """Load individual MP SVD vectors for a specific window.
+
+    Args:
+        db_path: Path to DuckDB database
+        window: Window ID (e.g., "2015", "current_parliament")
+
+    Returns:
+        {mp_name: np.ndarray(50,)} — one vector per MP
+    """
+    import json as _json
+
+    try:
+        con = duckdb.connect(database=db_path, read_only=True)
+        rows = con.execute(
+            """
+            SELECT entity_id, vector FROM svd_vectors
+            WHERE entity_type = 'mp' AND window_id = ?
+            """,
+            [window],
+        ).fetchall()
+        con.close()
+
+        mp_vecs: Dict[str, np.ndarray] = {}
+        for entity_id, raw_vec in rows:
+            if isinstance(raw_vec, str):
+                vec = _json.loads(raw_vec)
+            elif isinstance(raw_vec, (bytes, bytearray)):
+                vec = _json.loads(raw_vec.decode())
+            elif isinstance(raw_vec, list):
+                vec = raw_vec
+            else:
+                try:
+                    vec = list(raw_vec)
+                except Exception:
+                    continue
+            fvec = np.array([float(v) if v is not None else 0.0 for v in vec])
+            mp_vecs[entity_id] = fvec
+
+        return mp_vecs
+    except Exception:
+        logger.exception("Failed to load MP vectors for window %s", window)
+        return {}
+
+
+def query_similar(
+    db_path: str,
+    source_motion_id: int,
+    vector_type: str = "fused",
+    top_k: int = 10,
+) -> pd.DataFrame:
+    """Return top-k similar motions from similarity_cache (read-only)."""
+    try:
+        con = duckdb.connect(database=db_path, read_only=True)
+        rows = con.execute(
+            """
+            SELECT sc.target_motion_id, sc.score, sc.window_id,
+                   m.title, m.date, m.policy_area
+            FROM similarity_cache sc
+            JOIN motions m ON m.id = sc.target_motion_id
+            WHERE sc.source_motion_id = ?
+              AND sc.vector_type = ?
+            ORDER BY sc.score DESC
+            LIMIT ?
+            """,
+            [source_motion_id, vector_type, top_k],
+        ).fetchdf()
+        con.close()
+        return rows
+    except Exception:
+        logger.exception(
+            "Failed to query similarity cache for motion %s", source_motion_id
+        )
+        return pd.DataFrame()
+
+
+def load_mp_vectors_by_party(db_path: str) -> Dict[str, List[np.ndarray]]:
+    """Load individual MP SVD vectors grouped by party for current_parliament.
+
+    Returns:
+        {party_name: [np.ndarray(50,), ...]} — one array per MP.
+    """
+    import json as _json
+
+    try:
+        con = duckdb.connect(database=db_path, read_only=True)
+        meta_rows = con.execute(
+            "SELECT mp_name, party FROM mp_metadata "
+            "WHERE van >= '2023-11-22' OR tot_en_met IS NULL OR tot_en_met >= '2023-11-22' "
+            "ORDER BY van ASC"
+        ).fetchall()
+        mp_party: Dict[str, str] = {}
+        for mp_name, party in meta_rows:
+            if mp_name and party:
+                mp_party[mp_name] = _PARTY_NORMALIZE.get(party, party)
+
+        rows = con.execute(
+            "SELECT entity_id, vector FROM svd_vectors "
+            "WHERE entity_type='mp' AND window_id='current_parliament'"
+        ).fetchall()
+        con.close()
+
+        party_vecs: Dict[str, List[np.ndarray]] = {}
+        for entity_id, raw_vec in rows:
+            party = mp_party.get(entity_id)
+            if party is None or party not in CURRENT_PARLIAMENT_PARTIES:
+                continue
+            if isinstance(raw_vec, str):
+                vec = _json.loads(raw_vec)
+            elif isinstance(raw_vec, (bytes, bytearray)):
+                vec = _json.loads(raw_vec.decode())
+            elif isinstance(raw_vec, list):
+                vec = raw_vec
+            else:
+                try:
+                    vec = list(raw_vec)
+                except Exception:
+                    continue
+            fvec = np.array([float(v) if v is not None else 0.0 for v in vec])
+            party_vecs.setdefault(party, []).append(fvec)
+        return party_vecs
+    except Exception:
+        logger.exception("Failed to load MP vectors by party")
+        return {}
+
+
+def load_mp_vectors_by_party_for_window(
+    db_path: str, window: str
+) -> Dict[str, List[np.ndarray]]:
+    """Load individual MP SVD vectors grouped by party for a specific window.
+
+    For historical windows, uses the MP→party mapping from that time period.
+
+    Returns:
+        {party_name: [np.ndarray(50,), ...]} — one array per MP.
+    """
+    import json as _json
+
+    try:
+        con = duckdb.connect(database=db_path, read_only=True)
+        is_current = window == "current_parliament"
+
+        if is_current:
+            meta_rows = con.execute(
+                "SELECT mp_name, party FROM mp_metadata "
+                "WHERE van >= '2023-11-22' OR tot_en_met IS NULL OR tot_en_met >= '2023-11-22' "
+                "ORDER BY van ASC"
+            ).fetchall()
+        else:
+            try:
+                year = int(window.split("-")[0])
+            except ValueError:
+                year = 2023
+            meta_rows = con.execute(
+                "SELECT mp_name, party FROM mp_metadata "
+                "WHERE van <= ? AND (tot_en_met IS NULL OR tot_en_met >= ?) "
+                "ORDER BY van ASC",
+                [f"{year}-12-31", f"{year}-01-01"],
+            ).fetchall()
+
+        mp_party: Dict[str, str] = {}
+        for mp_name, party in meta_rows:
+            if mp_name and party:
+                mp_party[mp_name] = _PARTY_NORMALIZE.get(party, party)
+
+        rows = con.execute(
+            "SELECT entity_id, vector FROM svd_vectors "
+            "WHERE entity_type='mp' AND window_id=?",
+            [window],
+        ).fetchall()
+        con.close()
+
+        party_vecs: Dict[str, List[np.ndarray]] = {}
+        for entity_id, raw_vec in rows:
+            party = mp_party.get(entity_id)
+            if party is None:
+                continue
+            if is_current and party not in CURRENT_PARLIAMENT_PARTIES:
+                continue
+            if isinstance(raw_vec, str):
+                vec = _json.loads(raw_vec)
+            elif isinstance(raw_vec, (bytes, bytearray)):
+                vec = _json.loads(raw_vec.decode())
+            elif isinstance(raw_vec, list):
+                vec = raw_vec
+            else:
+                try:
+                    vec = list(raw_vec)
+                except Exception:
+                    continue
+            fvec = np.array([float(v) if v is not None else 0.0 for v in vec])
+            party_vecs.setdefault(party, []).append(fvec)
+        return party_vecs
+    except Exception:
+        logger.exception("Failed to load MP vectors by party for window %s", window)
+        return {}
+
+
+def compute_party_axis_scores(
+    party_vecs: Dict[str, List[np.ndarray]],
+) -> Dict[str, List[float]]:
+    """Compute per-party axis scores as mean of MP vectors.
+
+    Returns:
+        {party_name: [float * k]} — k = 50, mean over all MPs in that party.
+    """
+    try:
+        return {
+            party: np.array(vecs).mean(axis=0).tolist()
+            for party, vecs in party_vecs.items()
+        }
+    except Exception:
+        logger.exception("Failed to compute party axis scores")
+        return {}
+
+
+def load_positions(
+    db_path: str, window_size: str = "annual"
+) -> Tuple[Dict[str, Dict[str, Tuple[float, float]]], Dict]:
+    """Compute 2D positions per window using PCA on aligned SVD vectors.
+
+    Returns:
+        positions_by_window: {window_id: {entity_name: (x, y)}}
+        axis_def: dict with x_axis, y_axis, method keys
+    """
+    from analysis.political_axis import compute_2d_axes
+
+    all_available = get_uniform_dim_windows(db_path)
+
+    if not all_available:
+        return {}, {}
+
+    positions_by_window, axis_def = compute_2d_axes(
+        db_path,
+        window_ids=all_available,
+        method="pca",
+        pca_residual=True,
+        normalize_vectors=True,
+    )
+
+    try:
+        from analysis.axis_classifier import classify_axes
+
+        axis_def = classify_axes(positions_by_window, axis_def, db_path)
+    except Exception:
+        logger.exception("classify_axes failed; using generic axis labels")
+
+    if window_size == "annual":
+        annual_keys = set(w for w in all_available if "-Q" not in w)
+        positions_by_window = {
+            w: v for w, v in positions_by_window.items() if w in annual_keys
+        }
+
+    return positions_by_window, axis_def
+
+
+def get_aligned_party_scores(
+    db_path: str, window: str, active_mps: set | None = None
+) -> Dict[str, np.ndarray]:
+    """Get party scores for all N components from aligned PCA positions.
+
+    For current_parliament, pass active_mps to filter to only seated MPs
+    (matching the compass behaviour). Historical windows include all MPs.
+    """
+    from analysis.political_axis import compute_nd_axes
+
+    annual_windows = get_uniform_dim_windows(db_path)
+    scores_by_window, _ = compute_nd_axes(
+        db_path, window_ids=annual_windows, n_components=10
+    )
+    window_scores = scores_by_window.get(window, {})
+    if not window_scores:
+        return {}
+
+    if window == "current_parliament" and active_mps is not None:
+        window_scores = {mp: sc for mp, sc in window_scores.items() if mp in active_mps}
+
+    _party_map = load_party_map(db_path)
+
+    n_comps = 10
+    party_scores_agg: Dict[str, List[np.ndarray]] = {}
+    for mp_name, scores in window_scores.items():
+        party = _party_map.get(
+            mp_name, _party_map.get(mp_name.split("(")[0].strip(), None)
+        )
+        if party:
+            party_scores_agg.setdefault(party, []).append(scores[:n_comps])
+
+    return {
+        party: np.mean(np.vstack(score_list), axis=0)
+        for party, score_list in party_scores_agg.items()
+        if score_list
+    }
+
+
+def compute_party_discipline(
+    db_path: str,
+    start_date: str,
+    end_date: str,
+) -> pd.DataFrame:
+    """Compute per-party voting discipline (Rice index) for roll-call votes in a date range.
+
+    Only individual MP vote rows are used (mp_name LIKE '%,%').
+    Returns a DataFrame with columns [party, n_motions, discipline] sorted by discipline ascending.
+    Returns an empty DataFrame if fewer than 1 qualifying motion exists or on any DB error.
+    """
+    from analysis import trajectory
+
+    return trajectory.compute_party_discipline(db_path, start_date, end_date)
+
+
+def _get_aligned_trajectory_scores(
+    db_path: str, windows: List[str], n_components: int = 10
+) -> Dict[str, Dict[str, List[float]]]:
+    """Get aligned PCA scores for all windows as {window: {party: [scores per component]}}.
+
+    Uses compute_nd_axes to get PCA-projected, flip-corrected scores across all windows,
+    ensuring consistency with the single-window SVD components view.
+
+    Computes the global PCA basis on *all* uniform-dim windows (matching
+    get_aligned_party_scores) so that trajectory scores are numerically
+    consistent with the single-window view even when the caller passes a
+    subset of windows for display.
+    """
+    from analysis.political_axis import compute_nd_axes
+
+    all_uniform_windows = get_uniform_dim_windows(db_path)
+    scores_by_window, _ = compute_nd_axes(
+        db_path, window_ids=all_uniform_windows, n_components=n_components
+    )
+    if not scores_by_window:
+        return {}
+
+    party_map = load_party_map(db_path)
+    active_mps = load_active_mps(db_path)
+
+    result: Dict[str, Dict[str, List[float]]] = {}
+    for window in windows:
+        window_scores = scores_by_window.get(window, {})
+        if not window_scores:
+            continue
+
+        # For current_parliament, match single-window view by filtering to
+        # only MPs who are still seated (active). Historical windows include
+        # all MPs present in that window.
+        if window == "current_parliament":
+            window_scores = {
+                mp: sc for mp, sc in window_scores.items() if mp in active_mps
+            }
+
+        party_vecs: Dict[str, List[np.ndarray]] = {}
+        for mp_name, scores in window_scores.items():
+            party = party_map.get(
+                mp_name, party_map.get(mp_name.split("(")[0].strip(), None)
+            )
+            if party:
+                party_vecs.setdefault(party, []).append(scores[:n_components])
+
+        result[window] = {
+            party: np.mean(np.vstack(score_list), axis=0).tolist()
+            for party, score_list in party_vecs.items()
+            if score_list
+        }
+
+    return result

analysis/political_axis.py

@@ -1,13 +1,13 @@
 """political_axis.py — Project MP SVD vectors onto an ideological axis.
 
 Two modes:
-  1. PCA mode (default): compute the first principal component of all MP SVD
-     vectors for a window and project each MP onto it.  The sign is arbitrary
-     but consistent within a window.
+ 1. PCA mode (default): compute the first principal component of all MP SVD
+    vectors for a window and project each MP onto it.  The sign is arbitrary
+    but consistent within a window.
 
-  2. Anchor mode: define the axis as the vector from the centroid of
-     ``left_parties`` to the centroid of ``right_parties``.  Project all MPs
-     onto this normalised anchor axis.
+ 2. Anchor mode: define the axis as the vector from the centroid of
+    ``left_parties`` to the centroid of ``right_parties``.  Project all MPs
+    onto this normalised anchor axis.
 
 Both modes return a dict mapping mp_name → scalar score for the given window.
 """
@@ -18,7 +18,18 @@ from typing import Dict, List, Optional, Tuple
 
 import numpy as np
 from . import trajectory as _trajectory
-import duckdb
+
+try:
+    import duckdb
+except Exception:  # pragma: no cover - allow importing module in lightweight test envs
+    duckdb = None  # type: ignore
+
+# Import canonical party sets from config for consistent orientation with SVD components tab
+try:
+    from .config import CANONICAL_LEFT, CANONICAL_RIGHT
+except Exception:  # pragma: no cover - fallback for test environments
+    CANONICAL_LEFT: frozenset = frozenset()
+    CANONICAL_RIGHT: frozenset = frozenset()
 
 _logger = logging.getLogger(__name__)
 
@@ -257,38 +268,18 @@ def compute_2d_axes(
             "pca_residual_used": bool(pca_residual or evr1 > 0.85),
         }
 
+        # Canonical party sets used for axis orientation (global and per-window).
+        # Use CANONICAL_LEFT/RIGHT from config for consistency with SVD components tab.
+        # X-axis: CANONICAL_RIGHT (right) vs CANONICAL_LEFT (left)
+        # Y-axis: CANONICAL_LEFT (progressive) vs cons_parties (conservative)
+        right_parties = CANONICAL_RIGHT
+        left_parties = CANONICAL_LEFT
+        cons_parties = CANONICAL_RIGHT  # Conservative = right-leaning parties
+        prog_parties = CANONICAL_LEFT  # Progressive = left-leaning parties
+
         # Ensure consistent left/right and progressive/conservative orientation
         # by checking canonical party centroids and flipping axis signs if needed.
         try:
-            right_parties = {
-                "PVV",
-                "VVD",
-                "FVD",
-                "BBB",
-                "JA21",
-                "Nieuw Sociaal Contract",
-            }
-            left_parties = {"SP", "PvdA", "GL", "GroenLinks", "GroenLinks-PvdA", "DENK"}
-            cons_parties = {
-                "PVV",
-                "VVD",
-                "FVD",
-                "CDA",
-                "SGP",
-                "BBB",
-                "JA21",
-                "Nieuw Sociaal Contract",
-            }
-            prog_parties = {
-                "GL",
-                "GroenLinks",
-                "PvdA",
-                "PvdD",
-                "SP",
-                "GroenLinks-PvdA",
-                "DENK",
-            }
-
             # Build mapping of entity -> vector from stacked matrix M
             ent_to_vec = {ent: vec for (wid, ent), vec in zip(entity_index, M)}
 
@@ -358,6 +349,7 @@ def compute_2d_axes(
 
         # project per-window vectors (centre by global mean)
         global_mean = M.mean(axis=0)
+        axes["global_mean"] = global_mean
         positions_by_window: Dict[str, Dict[str, Tuple[float, float]]] = {
             wid: {} for wid in window_ids
         }
@@ -367,6 +359,109 @@ def compute_2d_axes(
             y = float(np.dot(v_centered, axes["y_axis"]))
             positions_by_window[wid][ent] = (x, y)
 
+        # Per-window Y-axis correction: ensure "positive Y = progressive" holds
+        # for EACH window individually. The global orientation check above uses
+        # centroids averaged across all windows, so individual windows (e.g. an
+        # election year with few returning MPs) can still be inverted. We check
+        # each window and flip its Y values if conservative parties sit above
+        # progressive ones.
+        try:
+            # Fetch mp_metadata once for the per-window check
+            _mp_meta_rows: List[Tuple[str, str]] = []
+            try:
+                conn = duckdb.connect(db_path)
+                _mp_meta_rows = conn.execute(
+                    "SELECT mp_name, party FROM mp_metadata"
+                ).fetchall()
+                conn.close()
+            except Exception:
+                pass  # no DB available (e.g. unit tests without metadata)
+
+            # Map mp_name -> party
+            _mp_party: Dict[str, str] = {r[0]: r[1] for r in _mp_meta_rows}
+
+            y_flipped_windows: set = set()
+            for wid, pos_dict in positions_by_window.items():
+                prog_ys = []
+                cons_ys = []
+                for ent, (x_val, y_val) in pos_dict.items():
+                    # direct party entity
+                    if ent in prog_parties:
+                        prog_ys.append(y_val)
+                    elif ent in cons_parties:
+                        cons_ys.append(y_val)
+                    # individual MP via metadata lookup
+                    party = _mp_party.get(ent)
+                    if party is not None:
+                        if party in prog_parties:
+                            prog_ys.append(y_val)
+                        elif party in cons_parties:
+                            cons_ys.append(y_val)
+
+                if prog_ys and cons_ys:
+                    prog_avg = float(np.mean(prog_ys))
+                    cons_avg = float(np.mean(cons_ys))
+                    if cons_avg > prog_avg:
+                        _logger.info(
+                            "Per-window Y flip for window %s: "
+                            "prog_avg_y=%.3f cons_avg_y=%.3f — negating Y",
+                            wid,
+                            prog_avg,
+                            cons_avg,
+                        )
+                        positions_by_window[wid] = {
+                            ent: (x_val, -y_val)
+                            for ent, (x_val, y_val) in pos_dict.items()
+                        }
+                        y_flipped_windows.add(wid)
+
+            axes["y_flipped_windows"] = y_flipped_windows
+
+            # Per-window X-axis correction: mirror the Y-axis logic above.
+            # The global X-flip uses centroids averaged across all windows, so
+            # individual windows can still have left/right inverted.
+            x_flipped_windows: set = set()
+            for wid, pos_dict in positions_by_window.items():
+                right_xs = []
+                left_xs = []
+                for ent, (x_val, y_val) in pos_dict.items():
+                    # direct party entity
+                    if ent in right_parties:
+                        right_xs.append(x_val)
+                    elif ent in left_parties:
+                        left_xs.append(x_val)
+                    # individual MP via metadata lookup
+                    party = _mp_party.get(ent)
+                    if party is not None:
+                        if party in right_parties:
+                            right_xs.append(x_val)
+                        elif party in left_parties:
+                            left_xs.append(x_val)
+
+                if right_xs and left_xs:
+                    right_avg = float(np.mean(right_xs))
+                    left_avg = float(np.mean(left_xs))
+                    if left_avg > right_avg:
+                        _logger.info(
+                            "Per-window X flip for window %s: "
+                            "right_avg_x=%.3f left_avg_x=%.3f — negating X",
+                            wid,
+                            right_avg,
+                            left_avg,
+                        )
+                        positions_by_window[wid] = {
+                            ent: (-x_val, y_val)
+                            for ent, (x_val, y_val) in pos_dict.items()
+                        }
+                        x_flipped_windows.add(wid)
+
+            axes["x_flipped_windows"] = x_flipped_windows
+
+        except Exception:
+            _logger.debug(
+                "Per-window orientation check failed; leaving per-window axes as-is"
+            )
+
         return positions_by_window, axes
 
     elif method == "anchor":
@@ -445,3 +540,294 @@ def compute_2d_axes(
 
     else:
         raise ValueError("Unknown method '%s'" % method)
+
+
+def compute_nd_axes(
+    db_path: str,
+    window_ids: Optional[List[str]] = None,
+    n_components: int = 10,
+    normalize_vectors: bool = True,
+) -> Tuple[Dict[str, Dict[str, np.ndarray]], Dict]:
+    """Compute aligned PCA projections onto N components for MPs per window.
+
+    This extends compute_2d_axes to return projections onto all N principal
+    components (not just the first 2), enabling consistent aligned positioning
+    for SVD components 1-10 in the explorer.
+
+    Args:
+        db_path: path to duckdb
+        window_ids: optional ordered list of windows (defaults to all)
+        n_components: number of PCA components to compute (default 10)
+        normalize_vectors: whether to normalize vectors before PCA (default True)
+
+    Returns:
+        scores_by_window, axes_def
+        - scores_by_window: {window_id: {entity: np.ndarray of shape (n_components,)}}
+        - axes_def: dict with 'components' (list of component vectors),
+          'explained_variance_ratio', 'global_mean', etc.
+    """
+    import importlib
+
+    _trajectory = importlib.import_module("analysis.trajectory")
+
+    if window_ids is None:
+        window_ids = _trajectory._load_window_ids(db_path)
+
+    # Load per-window raw vectors and align them
+    raw_window_vecs: Dict[str, Dict[str, np.ndarray]] = {}
+    for wid in window_ids:
+        raw_window_vecs[wid] = _trajectory._load_mp_vectors_for_window(db_path, wid)
+
+    # Pad all vectors to maximum dimension across windows
+    if raw_window_vecs:
+        max_dim = max(v.shape[0] for d in raw_window_vecs.values() for v in d.values())
+        padded: Dict[str, Dict[str, np.ndarray]] = {}
+        for wid, d in raw_window_vecs.items():
+            padded[wid] = {
+                e: np.pad(v, (0, max_dim - v.shape[0])) if v.shape[0] < max_dim else v
+                for e, v in d.items()
+            }
+        raw_window_vecs = padded
+
+    aligned_window_vecs = _trajectory._procrustes_align_windows(raw_window_vecs)
+
+    # Stack all aligned vectors across windows
+    all_vecs = []
+    entity_index = []  # parallel list of (window_id, entity)
+    for wid, d in aligned_window_vecs.items():
+        for ent, v in d.items():
+            if normalize_vectors:
+                n = np.linalg.norm(v)
+                all_vecs.append(v / n if n > 1e-10 else v)
+            else:
+                all_vecs.append(v)
+            entity_index.append((wid, ent))
+
+    if len(all_vecs) == 0:
+        _logger.info("No vectors loaded for windows %s", window_ids)
+        return ({}, {})
+
+    M = np.vstack(all_vecs)
+    global_mean = M.mean(axis=0)
+
+    # PCA: centre globally and compute SVD
+    Mc = M - global_mean
+    try:
+        U, s, Vt = np.linalg.svd(Mc, full_matrices=False)
+    except np.linalg.LinAlgError:
+        _logger.exception("SVD failed in compute_nd_axes")
+        return ({}, {})
+
+    # Explained variance ratio for each component
+    sv2 = s**2
+    evr = sv2 / (sv2.sum() + 1e-20)
+    explained_variance_ratio = evr[:n_components].tolist()
+
+    # Component directions (normalized)
+    components = [
+        Vt[i] / (np.linalg.norm(Vt[i]) + 1e-12)
+        for i in range(min(n_components, Vt.shape[0]))
+    ]
+
+    # Build entity -> vector mapping
+    ent_to_vec = {ent: vec for (wid, ent), vec in zip(entity_index, M)}
+
+    # Per-component flip directions using canonical party centroids
+    right_parties = CANONICAL_RIGHT
+    left_parties = CANONICAL_LEFT
+
+    def _centroid_for_party_set(party_set):
+        vecs = []
+        for p in party_set:
+            if p in ent_to_vec:
+                vecs.append(ent_to_vec[p])
+        try:
+            conn = duckdb.connect(db_path)
+            rows = conn.execute("SELECT mp_name, party FROM mp_metadata").fetchall()
+            conn.close()
+        except Exception:
+            rows = []
+        for mp_name, party in rows:
+            if party in party_set and mp_name in ent_to_vec:
+                vecs.append(ent_to_vec[mp_name])
+        if not vecs:
+            return None
+        return np.mean(np.vstack(vecs), axis=0)
+
+    left_cent = _centroid_for_party_set(left_parties)
+    right_cent = _centroid_for_party_set(right_parties)
+
+    # Compute flip signs per component
+    flip_signs = []
+    if left_cent is not None and right_cent is not None:
+        for i, comp in enumerate(components):
+            left_proj = float(np.dot(left_cent - global_mean, comp))
+            right_proj = float(np.dot(right_cent - global_mean, comp))
+            # Flip if right parties project lower than left (we want RIGHT > LEFT)
+            flip_signs.append(-1.0 if right_proj < left_proj else 1.0)
+    else:
+        flip_signs = [1.0] * len(components)
+
+    # Project all entities onto all components
+    scores_by_window: Dict[str, Dict[str, np.ndarray]] = {wid: {} for wid in window_ids}
+    for (wid, ent), vec in zip(entity_index, M):
+        v_centered = vec - global_mean
+        scores = np.array(
+            [
+                flip_signs[i] * float(np.dot(v_centered, components[i]))
+                for i in range(len(components))
+            ]
+        )
+        scores_by_window[wid][ent] = scores
+
+    axes_def = {
+        "components": components,
+        "explained_variance_ratio": explained_variance_ratio,
+        "global_mean": global_mean,
+        "flip_signs": flip_signs,
+        "n_components": len(components),
+    }
+
+    return scores_by_window, axes_def
+
+
+def compute_svd_spectrum(
+    db_path: str,
+    window_ids: Optional[List[str]] = None,
+    normalize_vectors: bool = True,
+) -> List[float]:
+    """Return explained variance ratios (%) for all SVD components, sorted descending.
+
+    Uses the same Procrustes-aligned multi-window matrix as compute_2d_axes so the
+    scree plot is consistent with the compass axes.
+
+    Args:
+        db_path: path to duckdb
+        window_ids: optional ordered list of windows (defaults to all)
+        normalize_vectors: whether to L2-normalise each MP vector before stacking
+
+    Returns:
+        List of EVR percentages sorted descending (e.g. [24.1, 10.4, 7.2, ...])
+    """
+    import importlib
+
+    _trajectory = importlib.import_module("analysis.trajectory")
+
+    if window_ids is None:
+        window_ids = _trajectory._load_window_ids(db_path)
+
+    raw_window_vecs: Dict[str, Dict[str, np.ndarray]] = {}
+    for wid in window_ids:
+        raw_window_vecs[wid] = _trajectory._load_mp_vectors_for_window(db_path, wid)
+
+    if not raw_window_vecs:
+        return []
+
+    # Pad to uniform dimension before Procrustes alignment
+    max_dim = max(v.shape[0] for d in raw_window_vecs.values() for v in d.values())
+    padded: Dict[str, Dict[str, np.ndarray]] = {}
+    for wid, d in raw_window_vecs.items():
+        padded[wid] = {
+            e: np.pad(v, (0, max_dim - v.shape[0])) if v.shape[0] < max_dim else v
+            for e, v in d.items()
+        }
+
+    aligned = _trajectory._procrustes_align_windows(padded)
+
+    all_vecs = []
+    for d in aligned.values():
+        for v in d.values():
+            if normalize_vectors:
+                n = np.linalg.norm(v)
+                all_vecs.append(v / n if n > 1e-10 else v)
+            else:
+                all_vecs.append(v)
+
+    if not all_vecs:
+        return []
+
+    M = np.vstack(all_vecs)
+    Mc = M - M.mean(axis=0)
+    try:
+        _, s, _ = np.linalg.svd(Mc, full_matrices=False)
+    except np.linalg.LinAlgError:
+        _logger.exception("SVD failed in compute_svd_spectrum")
+        return []
+
+    sv2 = s**2
+    evr = sv2 / (sv2.sum() + 1e-20) * 100
+    return list(evr)  # already sorted descending by SVD
+
+
+def compute_party_bootstrap_cis(
+    party_vectors: Dict[str, List[np.ndarray]],
+    n_boot: int = 1000,
+    ci: float = 95.0,
+    seed: int = 42,
+) -> Dict[str, Dict]:
+    """Compute bootstrap confidence intervals for party centroid vectors.
+
+    For each party, resamples its MP vectors with replacement to build a
+    distribution of centroid estimates, then extracts percentile-based
+    confidence intervals per dimension.
+
+    Args:
+        party_vectors: mapping of party name → list of individual MP vectors
+            (each a numpy array of consistent length, e.g. 50 dimensions).
+        n_boot: number of bootstrap replicates.
+        ci: confidence level as a percentage (e.g. 95.0 for 95% CI).
+        seed: random seed for reproducibility (used with ``np.random.default_rng``).
+
+    Returns:
+        Dict mapping party name → dict with keys ``centroid``, ``ci_lower``,
+        ``ci_upper``, ``std``, and ``n_mps``.  Parties with no MPs (empty
+        list) are excluded from the output.
+    """
+    alpha = 100.0 - ci
+    lo_pct = alpha / 2.0
+    hi_pct = 100.0 - lo_pct
+
+    rng = np.random.default_rng(seed)
+    result: Dict[str, Dict] = {}
+
+    for party, vectors in party_vectors.items():
+        n_mps = len(vectors)
+
+        if n_mps == 0:
+            continue
+
+        mat = np.vstack(vectors)  # (n_mps, dim)
+        centroid = np.mean(mat, axis=0)
+
+        if n_mps == 1:
+            result[party] = {
+                "centroid": centroid,
+                "ci_lower": centroid.copy(),
+                "ci_upper": centroid.copy(),
+                "std": np.zeros_like(centroid),
+                "n_mps": 1,
+            }
+            continue
+
+        idx = rng.integers(0, n_mps, size=(n_boot, n_mps))
+        boot_centroids = mat[idx].mean(axis=1)  # (n_boot, dim)
+
+        ci_lower = np.percentile(boot_centroids, lo_pct, axis=0)
+        ci_upper = np.percentile(boot_centroids, hi_pct, axis=0)
+        std = np.std(boot_centroids, axis=0)
+
+        result[party] = {
+            "centroid": centroid,
+            "ci_lower": ci_lower,
+            "ci_upper": ci_upper,
+            "std": std,
+            "n_mps": n_mps,
+        }
+
+    _logger.info(
+        "Bootstrap CIs computed for %d parties (n_boot=%d, ci=%.1f%%)",
+        len(result),
+        n_boot,
+        ci,
+    )
+    return result

analysis/projections.py

@@ -0,0 +1,128 @@
+"""SVD projection utilities for the parliamentary explorer.
+
+Pure computation functions for projecting motions and entities onto ideological axes.
+No IO or external dependencies - fully testable without Streamlit or DuckDB.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any, Dict, List, Tuple
+
+__all__ = [
+    "should_swap_axes",
+    "swap_axes",
+    "project_motion_scores",
+    "normalize_coordinates",
+]
+
+
+def should_swap_axes(axis_def: dict) -> bool:
+    """Return True if the Y axis is economic left-right and the X axis is not.
+
+    When true, caller should swap x/y positions and metadata so the economic
+    dimension (welfare vs market) is conventionally on the horizontal axis.
+    """
+    economic_labels = {"Verzorgingsstaat–Marktwerking", "Links–Rechts"}
+    y_label = axis_def.get("y_label")
+    x_label = axis_def.get("x_label")
+    return y_label in economic_labels and x_label not in economic_labels
+
+
+def swap_axes(
+    positions_by_window: Dict[str, Dict[str, Tuple[float, float]]],
+    axis_def: dict,
+) -> Tuple[Dict[str, Dict[str, Tuple[float, float]]], dict]:
+    """Swap x and y in all positions and axis metadata.
+
+    Pure function — returns (new_positions_by_window, new_axis_def).
+    """
+    new_positions: Dict[str, Dict[str, Tuple[float, float]]] = {}
+    for wid, pos_dict in positions_by_window.items():
+        new_positions[wid] = {ent: (y, x) for ent, (x, y) in pos_dict.items()}
+
+    new_ax = dict(axis_def)
+    new_ax["x_label"] = axis_def.get("y_label")
+    new_ax["y_label"] = axis_def.get("x_label")
+
+    for x_key, y_key in [
+        ("x_quality", "y_quality"),
+        ("x_interpretation", "y_interpretation"),
+        ("x_top_motions", "y_top_motions"),
+        ("x_label_confidence", "y_label_confidence"),
+        ("x_axis", "y_axis"),
+    ]:
+        new_ax[x_key] = axis_def.get(y_key)
+        new_ax[y_key] = axis_def.get(x_key)
+
+    return new_positions, new_ax
+
+
+def project_motion_scores(
+    motion_scores: Dict[int, float], top_n: int = 5
+) -> Tuple[List[Tuple[int, float]], List[Tuple[int, float]]]:
+    """Split motion scores into positive and negative poles.
+
+    Args:
+        motion_scores: Dict mapping motion_id to loading score
+        top_n: Number of top motions per pole
+
+    Returns:
+        Tuple of (positive_pole, negative_pole) where each is a list of (motion_id, score)
+    """
+    sorted_scores = sorted(motion_scores.items(), key=lambda x: x[1], reverse=True)
+
+    positive_pole = sorted_scores[:top_n]
+    negative_pole = sorted_scores[-top_n:][::-1]
+
+    return positive_pole, negative_pole
+
+
+def normalize_coordinates(
+    positions: Dict[str, Tuple[float, float]],
+    clamp_abs_value: float = 1e3,
+    null_tokens: Tuple[str, ...] = ("nan", "NaN", "None", "none", "null", ""),
+) -> Dict[str, Tuple[float, float]]:
+    """Normalize coordinate values.
+
+    Pure function that clamps extreme values and handles null tokens.
+
+    Args:
+        positions: Dict mapping entity names to (x, y) coordinates
+        clamp_abs_value: Maximum absolute coordinate value
+        null_tokens: Values to treat as null
+
+    Returns:
+        Dict with normalized coordinates
+    """
+
+    def _coerce(val: Any) -> float:
+        if val is None:
+            return float("nan")
+        if isinstance(val, (float, int)):
+            v = float(val)
+            if math.isnan(v) or math.isinf(v):
+                return float("nan")
+            if abs(v) > clamp_abs_value:
+                return float("nan")
+            return v
+        if isinstance(val, str):
+            if val in null_tokens or val.strip() in null_tokens:
+                return float("nan")
+            try:
+                v = float(val)
+                if math.isnan(v) or math.isinf(v):
+                    return float("nan")
+                if abs(v) > clamp_abs_value:
+                    return float("nan")
+                return v
+            except ValueError:
+                return float("nan")
+        return float("nan")
+
+    result = {}
+    for entity, (x, y) in positions.items():
+        nx = _coerce(x)
+        ny = _coerce(y)
+        result[entity] = (nx, ny)
+    return result

analysis/right_wing/build_all_reports.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""Regenerate all Overton window reports in correct dependency order.
+
+Usage:
+    uv run python analysis/right_wing/build_all_reports.py
+    uv run python analysis/right_wing/build_all_reports.py --skip-llm
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from analysis.right_wing.common import REPORTS_DIR
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger("build_all_reports")
+
+SCRIPT_DIR = ROOT / "analysis" / "right_wing"
+
+PHASE_1_SCRIPTS = [
+    "overton_breakpoint_analysis.py",
+    "temporal_trajectory.py",
+    "causal_timing.py",
+    "party_differentiation.py",
+    "voting_margin.py",
+    "left_wing_response.py",
+    "success_correlation.py",
+    "overton_svd_drift.py",
+    "svd_trajectory_viz.py",
+]
+
+PHASE_1_OUTPUTS = [
+    "breakpoint_analysis.md",
+    "breakpoint_figure_1.png",
+    "breakpoint_figure_2.png",
+    "breakpoint_figure_3.png",
+    "breakpoint_figure_4.png",
+    "temporal_trajectory.md",
+    "temporal_trajectory_figure.png",
+    "causal_timing.md",
+    "causal_timing_figure.png",
+    "party_differentiation.md",
+    "party_differentiation_figure.png",
+    "voting_margin.md",
+    "voting_margin_figure.png",
+    "left_wing_response.md",
+    "left_wing_response_figure.png",
+    "success_correlation.md",
+    "svd_drift_chart.png",
+    "svd_stability_report.md",
+    "svd_trajectory_figure.png",
+]
+
+PHASE_2_SCRIPTS = [
+    "extremity_2d_temporal.py",
+    "predictive_model.py",
+    "mechanism_classification.py",
+]
+
+PHASE_2_OUTPUTS = [
+    "extremity_2d_temporal.md",
+    "extremity_2d_temporal_figure.png",
+    "predictive_model.md",
+    "predictive_model_figure.png",
+    "mechanism_classification.md",
+]
+
+PHASE_3_SCRIPTS = [
+    "derive_categories.py",
+]
+
+
+def _script_path(name: str) -> str:
+    return str(SCRIPT_DIR / name)
+
+
+def _run_script(name: str) -> bool:
+    """Run a single script via subprocess. Returns True on success."""
+    logger.info("Running %s ...", name)
+    t0 = time.perf_counter()
+    try:
+        subprocess.run(
+            [sys.executable, _script_path(name)],
+            cwd=str(ROOT),
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        elapsed = time.perf_counter() - t0
+        logger.info("Finished %s (%.1fs)", name, elapsed)
+        return True
+    except subprocess.CalledProcessError as exc:
+        elapsed = time.perf_counter() - t0
+        logger.error("Script %s failed after %.1fs (rc=%d)", name, elapsed, exc.returncode)
+        if exc.stdout:
+            for line in exc.stdout.strip().splitlines():
+                logger.error("  stdout: %s", line)
+        if exc.stderr:
+            for line in exc.stderr.strip().splitlines():
+                logger.error("  stderr: %s", line)
+        return False
+
+
+def _verify_outputs(files: list[str]) -> list[str]:
+    """Return list of expected output files that are missing."""
+    missing = []
+    for f in files:
+        if not (REPORTS_DIR / f).exists():
+            missing.append(f)
+    return missing
+
+
+def _run_phase(
+    phase_label: str, scripts: list[str], expected_outputs: list[str]
+) -> tuple[list[str], list[str]]:
+    """Run a list of scripts and verify outputs. Returns (succeeded, failed)."""
+    logger.info("=" * 50)
+    logger.info("Phase %s", phase_label)
+    logger.info("=" * 50)
+
+    succeeded = []
+    failed = []
+
+    for script in scripts:
+        ok = _run_script(script)
+        if ok:
+            succeeded.append(script)
+        else:
+            failed.append(script)
+
+    missing = _verify_outputs(expected_outputs)
+    if missing:
+        logger.warning(
+            "Phase %s: %d expected output(s) missing after run:\n  %s",
+            phase_label,
+            len(missing),
+            "\n  ".join(missing),
+        )
+    else:
+        logger.info("Phase %s: all expected outputs present.", phase_label)
+
+    return succeeded, failed
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Regenerate all Overton window reports in dependency order."
+    )
+    parser.add_argument(
+        "--skip-llm",
+        action="store_true",
+        help="Skip LLM-dependent phase (derive_categories.py)",
+    )
+    args = parser.parse_args()
+
+    REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+    all_succeeded: list[str] = []
+    all_failed: list[str] = []
+    t_start = time.perf_counter()
+
+    # Phase 1: database-dependent (no LLM)
+    s, f = _run_phase("1 — database-dependent", PHASE_1_SCRIPTS, PHASE_1_OUTPUTS)
+    all_succeeded.extend(s)
+    all_failed.extend(f)
+
+    # Phase 2: 2D extremity-dependent (no LLM)
+    s, f = _run_phase("2 — 2D extremity-dependent", PHASE_2_SCRIPTS, PHASE_2_OUTPUTS)
+    all_succeeded.extend(s)
+    all_failed.extend(f)
+
+    # Phase 3: LLM-dependent
+    if not args.skip_llm:
+        s, f = _run_phase("3 — LLM-dependent", PHASE_3_SCRIPTS, [])
+        all_succeeded.extend(s)
+        all_failed.extend(f)
+    else:
+        logger.info("Skipping LLM-dependent phase (--skip-llm).")
+
+    # Phase 4: Synthesis reminder (manual)
+    print("\n" + "=" * 50)
+    print("PHASE 4 — MANUAL STEP REQUIRED")
+    print("=" * 50)
+    print("  After all scripts complete, manually update:")
+    print("    - reports/overton_window/overton_window_synthesis.md")
+    print("    - reports/overton_window/overton_window.qmd (then: quarto render)")
+    print("    - reports/overton_window/overton_report.html")
+    print("  These narrative files require human judgment to integrate")
+    print("  new data into the existing analysis framework.")
+    print("=" * 50)
+
+    total_elapsed = time.perf_counter() - t_start
+
+    # Summary
+    sep = "=" * 50
+    print(f"\n{sep}")
+    print("BUILD SUMMARY")
+    print(sep)
+    print(f"  Total time:  {total_elapsed:.1f}s")
+    print(f"  Succeeded:   {len(all_succeeded)}/{len(all_succeeded) + len(all_failed)}")
+    if all_succeeded:
+        print("  Scripts OK:")
+        for name in all_succeeded:
+            print(f"    ✓ {name}")
+    if all_failed:
+        print("  Scripts FAILED:")
+        for name in all_failed:
+            print(f"    ✗ {name}")
+    print(sep)
+
+    return 1 if all_failed else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/causal_timing.py

@@ -0,0 +1,886 @@
+#!/usr/bin/env python3
+"""U4: Causal timing analysis of the centrist support shift for right-wing motions.
+
+Identifies the exact timing of the shift, correlates with political events
+(Dutch and European), and tests whether the shift was immediate or gradual.
+
+Usage:
+    uv run python analysis/right_wing/causal_timing.py
+
+Output:
+    reports/overton_window/causal_timing.md
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+import duckdb
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+ROOT = Path(__file__).parent.parent.parent.resolve()
+sys.path.insert(0, str(ROOT))
+
+from analysis.right_wing.common import (
+    CANONICAL_CENTRIST, COALITION, DB_PATH, REPORTS_DIR,
+    build_party_name_map, parse_lead_submitter, quarter_sort_key,
+)
+REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+POLITICAL_EVENTS: list[dict[str, Any]] = [
+    {"quarter": "2021-Q1", "label": "Rutte IV\nelection",
+     "date": "Mar 2021", "category": "dutch"},
+    {"quarter": "2022-Q3", "label": "Sweden\nrightward shift",
+     "date": "Sep 2022", "category": "european"},
+    {"quarter": "2022-Q4", "label": "Meloni\n(Italy)",
+     "date": "Oct 2022", "category": "european"},
+    {"quarter": "2023-Q2", "label": "Finland\nrightward shift",
+     "date": "Apr 2023", "category": "european"},
+    {"quarter": "2023-Q4", "label": "PVV victory\n(Schoof election)",
+     "date": "Nov 2023", "category": "dutch"},
+    {"quarter": "2024-Q3", "label": "Schoof cabinet\nformation",
+     "date": "Jul 2024", "category": "dutch"},
+]
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def fetch_rw_motions(con: duckdb.DuckDBPyConnection) -> list[dict[str, Any]]:
+    rows = con.execute("""
+        SELECT
+            r.motion_id,
+            r.title,
+            r.centrist_support_strict,
+            r.category,
+            r.year,
+            m.date
+        FROM right_wing_motions r
+        JOIN motions m ON r.motion_id = m.id
+        WHERE r.classified = TRUE
+          AND r.centrist_support_strict IS NOT NULL
+          AND m.date IS NOT NULL
+        ORDER BY m.date
+    """).fetchall()
+
+    result = []
+    for mid, title, cs, cat, year, date in rows:
+        quarter = f"{date.year}-Q{(date.month - 1) // 3 + 1}"
+        result.append({
+            "motion_id": mid,
+            "title": title,
+            "centrist_support_strict": cs,
+            "category": cat,
+            "year": year,
+            "date": date,
+            "quarter": quarter,
+        })
+    return result
+
+
+def aggregate_quarterly(data: list[dict]) -> dict[str, dict]:
+    quarterly: dict[str, dict[str, list]] = defaultdict(
+        lambda: {"all_cs": []}
+    )
+
+    for row in data:
+        q = row["quarter"]
+        cs = row["centrist_support_strict"]
+        quarterly[q]["all_cs"].append(cs)
+
+    return dict(quarterly)
+
+
+def compute_summary(quarterly: dict) -> dict[str, dict[str, Any]]:
+    summary = {}
+    for q, buckets in quarterly.items():
+        entry: dict[str, Any] = {"quarter": q}
+        vals = np.array(buckets.get("all_cs", []))
+        n = len(vals)
+        entry["n"] = n
+        if n > 0:
+            entry["mean"] = float(np.mean(vals))
+            entry["std"] = float(np.std(vals, ddof=1)) if n > 1 else 0.0
+        else:
+            entry["mean"] = float("nan")
+            entry["std"] = float("nan")
+        summary[q] = entry
+    return summary
+
+
+def find_inflection_point(summary: dict, threshold: float = 0.4, min_n: int = 20) -> tuple[str | None, str | None]:
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+
+    raw_inflection = None
+    for q in quarters:
+        val = summary[q].get("mean", float("nan"))
+        n = summary[q].get("n", 0)
+        if not np.isnan(val) and val > threshold and n >= min_n:
+            raw_inflection = q
+            break
+
+    raw_mid = None
+    for q in quarters:
+        val = summary[q].get("mean", float("nan"))
+        n = summary[q].get("n", 0)
+        if not np.isnan(val) and val > 0.3 and n >= min_n:
+            raw_mid = q
+            break
+
+    rolling_inflection = None
+    window_size = 3
+    for i, q in enumerate(quarters):
+        if i < window_size - 1:
+            continue
+        window_vals = []
+        for j in range(i - window_size + 1, i + 1):
+            wq = quarters[j]
+            v = summary[wq].get("mean", float("nan"))
+            n_w = summary[wq].get("n", 0)
+            if not np.isnan(v) and n_w > 0:
+                window_vals.extend([v] * n_w)
+        if window_vals:
+            roll_mean = np.mean(window_vals)
+            total_n = sum(
+                summary[quarters[j]].get("n", 0)
+                for j in range(i - window_size + 1, i + 1)
+            )
+            if roll_mean > threshold and total_n >= min_n:
+                rolling_inflection = q
+                break
+
+    return raw_inflection, rolling_inflection
+
+
+def compute_qoq_deltas(summary: dict) -> list[dict[str, Any]]:
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+    deltas = []
+    for i in range(1, len(quarters)):
+        prev_q = quarters[i - 1]
+        curr_q = quarters[i]
+        prev_mean = summary[prev_q].get("mean", float("nan"))
+        curr_mean = summary[curr_q].get("mean", float("nan"))
+        prev_n = summary[prev_q].get("n", 0)
+        curr_n = summary[curr_q].get("n", 0)
+        if not np.isnan(prev_mean) and not np.isnan(curr_mean):
+            delta = curr_mean - prev_mean
+            deltas.append({
+                "from_quarter": prev_q,
+                "to_quarter": curr_q,
+                "delta": round(float(delta), 4),
+                "from_mean": round(float(prev_mean), 4),
+                "to_mean": round(float(curr_mean), 4),
+                "from_n": prev_n,
+                "to_n": curr_n,
+            })
+    return deltas
+
+
+def analyze_shift_shape(summary: dict, qoq_deltas: list[dict]) -> dict[str, Any]:
+    raw_inflection, rolling_inflection = find_inflection_point(summary)
+
+    reliable_deltas = [d for d in qoq_deltas if d["from_n"] >= 10 and d["to_n"] >= 10]
+    non_nan_reliable = [d["delta"] for d in reliable_deltas if not np.isnan(d["delta"])]
+    avg_delta = np.mean(np.abs(non_nan_reliable)) if non_nan_reliable else float("nan")
+
+    max_jump = max(reliable_deltas, key=lambda d: d["delta"], default=None)
+
+    pre_inflection_deltas = []
+    post_inflection_deltas = []
+    if raw_inflection:
+        for d in reliable_deltas:
+            if quarter_sort_key(d["to_quarter"]) <= quarter_sort_key(raw_inflection):
+                pre_inflection_deltas.append(d)
+            elif quarter_sort_key(d["from_quarter"]) >= quarter_sort_key(raw_inflection):
+                post_inflection_deltas.append(d)
+
+    pre_deltas = [d["delta"] for d in pre_inflection_deltas]
+    post_deltas = [d["delta"] for d in post_inflection_deltas]
+
+    max_abs_jump = max(non_nan_reliable) if non_nan_reliable else float("nan")
+    avg_abs_delta = np.mean(np.abs(non_nan_reliable)) if non_nan_reliable else float("nan")
+    # ratio > 3.0 suggests discrete jump, < 2.0 suggests gradual
+    jump_ratio = max_abs_jump / avg_abs_delta if avg_abs_delta and avg_abs_delta > 0 else float("nan")
+
+    pre_avg = np.mean(pre_deltas) if pre_deltas else float("nan")
+    post_avg = np.mean(post_deltas) if post_deltas else float("nan")
+
+    # Is there a single-quarter jump > 0.1? (only among reliable quarters with >= 20 motions each)
+    reliable_20 = [d for d in reliable_deltas if d["from_n"] >= 20 and d["to_n"] >= 20]
+    max_single_jump_q = None
+    max_single_jump_val = -1.0
+    for d in reliable_20:
+        if d["delta"] > 0.1 and d["delta"] > max_single_jump_val:
+            max_single_jump_val = d["delta"]
+            max_single_jump_q = d["to_quarter"]
+
+    # Also find the single-quarter jump around the inflection area specifically
+    post_2023_jumps = [d for d in reliable_deltas
+                       if quarter_sort_key(d["to_quarter"]) >= quarter_sort_key("2023-Q4")]
+    post_2023_max = max(post_2023_jumps, key=lambda d: d["delta"], default=None)
+
+    return {
+        "raw_inflection": raw_inflection,
+        "rolling_inflection": rolling_inflection,
+        "max_jump": max_jump,
+        "max_abs_jump": round(max_abs_jump, 4),
+        "avg_abs_delta": round(avg_abs_delta, 4),
+        "jump_ratio": round(jump_ratio, 2),
+        "immediate": max_single_jump_val > 0.1,
+        "max_single_jump_quarter": max_single_jump_q,
+        "max_single_jump_value": round(max_single_jump_val, 4),
+        "max_single_jump_from": max_jump["from_quarter"] if max_jump else None,
+        "post_2023_max_jump": {
+            "from_quarter": post_2023_max["from_quarter"],
+            "to_quarter": post_2023_max["to_quarter"],
+            "delta": round(post_2023_max["delta"], 4),
+        } if post_2023_max else None,
+        "pre_avg_delta": round(pre_avg, 4),
+        "post_avg_delta": round(post_avg, 4),
+    }
+
+
+def compute_event_proximity(
+    summary: dict,
+    raw_inflection: str | None,
+    events: list[dict[str, Any]],
+) -> dict[str, Any]:
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+
+    event_proximity = []
+    for evt in events:
+        eq = evt["quarter"]
+        if eq not in quarters:
+            prev_qs = [q for q in quarters if quarter_sort_key(q) < quarter_sort_key(eq)]
+            eq_actual = prev_qs[-1] if prev_qs else None
+        else:
+            eq_actual = eq
+
+        if eq_actual is None:
+            event_proximity.append({**evt, "cs_at_event": None, "n_quarters_before_inflection": None})
+            continue
+
+        cs_at_evt = summary.get(eq_actual, {}).get("mean", float("nan"))
+
+        n_before = None
+        if raw_inflection and quarter_sort_key(raw_inflection) > quarter_sort_key(eq_actual):
+            n_before = 0
+            for q in quarters:
+                if quarter_sort_key(q) > quarter_sort_key(eq_actual) and quarter_sort_key(q) <= quarter_sort_key(raw_inflection):
+                    n_before += 1
+
+        n_after = None
+        if raw_inflection and quarter_sort_key(eq_actual) >= quarter_sort_key(raw_inflection):
+            n_after = 0
+            for q in quarters:
+                if quarter_sort_key(q) >= quarter_sort_key(raw_inflection) and quarter_sort_key(q) <= quarter_sort_key(eq_actual):
+                    n_after += 1
+
+        event_proximity.append({
+            **evt,
+            "cs_at_event": round(float(cs_at_evt), 4) if not np.isnan(cs_at_evt) else None,
+            "n_quarters_before_inflection": n_before,
+            "n_quarters_after_inflection": n_after,
+        })
+
+    schoof_election_shift_onset = None
+    schoof_cabinet_shift_onset = None
+    if raw_inflection:
+        inf_key = quarter_sort_key(raw_inflection)
+        schoof_election_key = quarter_sort_key("2023-Q4")
+        schoof_cabinet_key = quarter_sort_key("2024-Q3")
+        schoof_election_shift_onset = inf_key > schoof_election_key
+        schoof_cabinet_shift_onset = inf_key >= schoof_cabinet_key
+
+    pre_election_key = quarter_sort_key("2023-Q3")
+    if raw_inflection:
+        inf_key = quarter_sort_key(raw_inflection)
+        shift_before_cabinet = inf_key < quarter_sort_key("2024-Q3")
+        shift_after_election = inf_key > quarter_sort_key("2023-Q4")
+    else:
+        shift_before_cabinet = None
+        shift_after_election = None
+
+    return {
+        "events": event_proximity,
+        "shift_after_schoof_election": schoof_election_shift_onset,
+        "shift_before_schoof_cabinet": shift_before_cabinet,
+        "shift_after_schoof_election": shift_after_election,
+        "interpretation": (
+            "shift began AFTER PVV election but BEFORE Schoof cabinet formation"
+            if shift_after_election and shift_before_cabinet
+            else "ambiguous"
+        ),
+    }
+
+
+def compute_shift_velocity(
+    summary: dict,
+    inflection_q: str,
+) -> dict[str, Any]:
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+    try:
+        idx = quarters.index(inflection_q)
+    except ValueError:
+        return {"error": "inflection quarter not found"}
+
+    pre_window = quarters[max(0, idx - 4):idx]
+    post_window = quarters[idx:min(len(quarters), idx + 4)]
+
+    pre_means = [
+        summary[q]["mean"] for q in pre_window
+        if not np.isnan(summary[q].get("mean", float("nan")))
+    ]
+    post_means = [
+        summary[q]["mean"] for q in post_window
+        if not np.isnan(summary[q].get("mean", float("nan")))
+    ]
+
+    pre_avg = np.mean(pre_means) if pre_means else float("nan")
+    post_avg = np.mean(post_means) if post_means else float("nan")
+
+    return {
+        "inflection_quarter": inflection_q,
+        "pre_4q_avg": round(float(pre_avg), 3),
+        "post_4q_avg": round(float(post_avg), 3),
+        "delta": round(float(post_avg - pre_avg), 3),
+        "pre_window_str": f"{pre_window[0]} to {pre_window[-1]}" if pre_window else "N/A",
+        "post_window_str": f"{post_window[0]} to {post_window[-1]}" if post_window else "N/A",
+    }
+
+
+def create_figure(
+    summary: dict,
+    inflection_q: str | None,
+    shape_analysis: dict,
+) -> str:
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+    q_labels = quarters
+    x = np.arange(len(quarters))
+    means = np.array([summary[q].get("mean", np.nan) for q in quarters])
+    ns = np.array([summary[q].get("n", 0) for q in quarters])
+
+    rolling = np.full(len(quarters), np.nan)
+    w = 3
+    for i in range(w - 1, len(quarters)):
+        window_vals = []
+        for j in range(i - w + 1, i + 1):
+            v = means[j]
+            nw = ns[j]
+            if not np.isnan(v) and nw > 0:
+                window_vals.extend([v] * int(nw))
+        if window_vals:
+            rolling[i] = np.mean(window_vals)
+
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(16, 10), gridspec_kw={"height_ratios": [2, 1]})
+
+    colour_main = "#002366"
+    colour_rolling = "#FF8F00"
+    colour_jump = "#D32F2F"
+
+    mask = ~np.isnan(means)
+    ax1.plot(x, means, marker="o", color=colour_main, linewidth=2, label="Centrist support (quarterly mean)", zorder=5)
+    ax1.plot(x, rolling, color=colour_rolling, linewidth=2.5, linestyle="-", alpha=0.8, label="3-Q rolling average", zorder=4)
+
+    if inflection_q and inflection_q in quarters:
+        inf_idx = quarters.index(inflection_q)
+        ax1.axvline(x=inf_idx, color=colour_jump, linestyle="--", alpha=0.6, linewidth=1.5)
+        ax1.annotate(
+            f"Inflection: {inflection_q}",
+            xy=(inf_idx, 0.4),
+            xytext=(inf_idx + 0.5, 0.52),
+            fontsize=9,
+            color=colour_jump,
+            fontweight="bold",
+            arrowprops=dict(arrowstyle="->", color=colour_jump, alpha=0.7),
+        )
+
+    ax1.axhline(y=0.4, color="grey", linestyle=":", alpha=0.4, linewidth=1)
+
+    max_jump_q = shape_analysis.get("max_single_jump_quarter")
+    if max_jump_q and max_jump_q in quarters:
+        mj_idx = quarters.index(max_jump_q)
+        ax1.axvline(x=mj_idx, color="#4CAF50", linestyle="--", alpha=0.5, linewidth=1)
+        ax1.annotate(
+            f"Max jump:\n+{shape_analysis['max_single_jump_value']:.2f}",
+            xy=(mj_idx, means[mj_idx]),
+            xytext=(mj_idx + 0.8, means[mj_idx] + 0.08),
+            fontsize=8,
+            color="#4CAF50",
+            arrowprops=dict(arrowstyle="->", color="#4CAF50", alpha=0.7),
+        )
+
+    dutch_events = [e for e in POLITICAL_EVENTS if e["category"] == "dutch"]
+    for evt in dutch_events:
+        eq = evt["quarter"]
+        if eq in quarters:
+            eidx = quarters.index(eq)
+            ax1.axvline(x=eidx, color="black", linestyle=":", alpha=0.3, linewidth=0.8)
+            ax1.annotate(
+                evt["label"],
+                xy=(eidx, 0.02),
+                fontsize=7,
+                color="black",
+                alpha=0.6,
+                ha="center",
+                va="bottom",
+            )
+
+    european_events = [e for e in POLITICAL_EVENTS if e["category"] == "european"]
+    for evt in european_events:
+        eq = evt["quarter"]
+        if eq in quarters:
+            eidx = quarters.index(eq)
+            ax1.axvline(x=eidx, color="#7B1FA2", linestyle=":", alpha=0.3, linewidth=0.8)
+            ax1.annotate(
+                evt["label"],
+                xy=(eidx, 0.95),
+                fontsize=6.5,
+                color="#7B1FA2",
+                alpha=0.6,
+                ha="center",
+                va="top",
+            )
+
+    for i, (xi, n_val, mean_val) in enumerate(zip(x, ns, means)):
+        if not np.isnan(n_val) and n_val < 10:
+            ax1.annotate(
+                f"n={int(n_val)}",
+                xy=(xi, mean_val if not np.isnan(mean_val) else 0),
+                fontsize=6,
+                color="grey",
+                alpha=0.6,
+                ha="center",
+                va="bottom",
+            )
+
+    ax1.set_ylabel("Centrist support (strict)")
+    ax1.set_title("Causal Timing: Centrist Support for Right-Wing Motions with Political Events", fontweight="bold")
+    ax1.legend(loc="upper left", fontsize=8, ncol=2)
+    ax1.set_ylim(0, 1.05)
+    ax1.grid(True, alpha=0.3)
+
+    # Subplot 2: Quarter-over-quarter deltas
+    qoq_deltas = []
+    qoq_labels = []
+    for i in range(1, len(quarters)):
+        prev = means[i - 1]
+        curr = means[i]
+        if not np.isnan(prev) and not np.isnan(curr):
+            qoq_deltas.append(curr - prev)
+            qoq_labels.append(quarters[i])
+
+    x2 = np.arange(len(qoq_deltas))
+    colours_bar = [colour_jump if d > 0.1 else ("#4CAF50" if d > 0 else "#90A4AE") for d in qoq_deltas]
+    ax2.bar(x2, qoq_deltas, color=colours_bar, alpha=0.7, edgecolor="white", linewidth=0.5)
+    ax2.axhline(y=0.1, color=colour_jump, linestyle="--", alpha=0.4, linewidth=1, label="Jump threshold (0.1)")
+    ax2.axhline(y=0, color="grey", linewidth=0.8)
+    ax2.set_ylabel("QoQ delta")
+    ax2.set_xlabel("Quarter")
+    ax2.set_title("Quarter-over-Quarter Change in Centrist Support", fontweight="bold")
+    ax2.legend(fontsize=8)
+    ax2.grid(True, alpha=0.3, axis="y")
+
+    step = max(1, len(qoq_labels) // 12)
+    ax2.set_xticks(x2[::step])
+    ax2.set_xticklabels([qoq_labels[i] for i in range(0, len(qoq_labels), step)], rotation=45, fontsize=8)
+
+    ax1.set_xticks(x[::2])
+    ax1.set_xticklabels([q_labels[i] for i in range(0, len(q_labels), 2)], rotation=45, fontsize=8)
+
+    plt.tight_layout()
+    path = str(REPORTS_DIR / "causal_timing_figure.png")
+    fig.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    logger.info("Saved figure to %s", path)
+    return path
+
+
+def generate_report(
+    summary: dict,
+    shape_analysis: dict,
+    proximity: dict,
+    velocity: dict,
+    qoq_deltas: list[dict],
+    fig_path: str,
+) -> str:
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+    last_q = quarters[-1] if quarters else "unknown"
+
+    # Compute period aggregates
+    raw_inflection = shape_analysis["raw_inflection"]
+    pre_qs = [q for q in quarters if quarter_sort_key(q) < quarter_sort_key(raw_inflection)] if raw_inflection else []
+    post_qs = [q for q in quarters if quarter_sort_key(q) >= quarter_sort_key(raw_inflection)] if raw_inflection else []
+
+    pre_means_vals = [summary[q]["mean"] for q in pre_qs if not np.isnan(summary[q].get("mean", float("nan")))]
+    post_means_vals = [summary[q]["mean"] for q in post_qs if not np.isnan(summary[q].get("mean", float("nan")))]
+
+    pre_avg = np.mean(pre_means_vals) if pre_means_vals else float("nan")
+    post_avg = np.mean(post_means_vals) if post_means_vals else float("nan")
+
+    total_n = sum(summary[q]["n"] for q in quarters)
+
+    # --- Event proximity table ---
+    event_rows = []
+    for evt in proximity["events"]:
+        cs_str = f"{evt['cs_at_event']:.3f}" if evt["cs_at_event"] is not None else "N/A"
+        if evt["n_quarters_before_inflection"] is not None:
+            timing = f"{evt['n_quarters_before_inflection']} quarters before shift"
+        elif evt["n_quarters_after_inflection"] is not None:
+            timing = f"{evt['n_quarters_after_inflection']} quarters after shift"
+        else:
+            timing = "N/A"
+        event_rows.append(
+            f"| {evt['quarter']} | {evt['date']} | {evt['label'].replace(chr(10), ' ')} | "
+            f"{evt['category']} | {cs_str} | {timing} |"
+        )
+
+    # --- Velocity table ---
+    pre_inf_cs_vals = [
+        summary[q]["mean"] for q in quarters
+        if raw_inflection and quarter_sort_key(q) < quarter_sort_key(raw_inflection)
+        and not np.isnan(summary[q].get("mean", float("nan")))
+    ]
+    post_inf_cs_vals = [
+        summary[q]["mean"] for q in quarters
+        if raw_inflection and quarter_sort_key(q) >= quarter_sort_key(raw_inflection)
+        and not np.isnan(summary[q].get("mean", float("nan")))
+    ]
+    pre_inf_mean = np.mean(pre_inf_cs_vals) if pre_inf_cs_vals else float("nan")
+    post_inf_mean = np.mean(post_inf_cs_vals) if post_inf_cs_vals else float("nan")
+
+    # --- Interpretation ---
+    max_jump = shape_analysis["max_jump"]
+    post2023 = shape_analysis.get("post_2023_max_jump")
+    structural_break_jump = post2023["delta"] if post2023 else float("nan")
+    structural_break_from = post2023["from_quarter"] if post2023 else "N/A"
+    structural_break_to = post2023["to_quarter"] if post2023 else "N/A"
+    immediate_test = shape_analysis["immediate"]
+    immediate_desc = (
+        "**IMMEDIATE** — the structural break jump ({structural_break_from} -> {structural_break_to}) "
+        "was +{structural_break_jump:.3f}, exceeding the 0.1 threshold.".format(
+            structural_break_from=structural_break_from,
+            structural_break_to=structural_break_to,
+            structural_break_jump=structural_break_jump,
+        )
+        if immediate_test and post2023 and structural_break_jump > 0.1
+        else (
+            "**GRADUAL** — no single-quarter jump exceeding 0.1 was detected."
+        )
+    )
+
+    jump_desc = ""
+    if max_jump and max_jump["delta"] > 0.1:
+        jump_desc = (
+            f"The largest single-quarter jump was +{max_jump['delta']:.3f} "
+            f"({max_jump['from_quarter']} -> {max_jump['to_quarter']}). "
+        )
+    else:
+        jump_desc = "No single-quarter jump > 0.1 was detected among reliable quarters. "
+
+    if post2023 and structural_break_jump > 0.1:
+        jump_desc += (
+            f"However, the **structural break** occurs at the shift onset: "
+            f"+{structural_break_jump:.3f} "
+            f"({structural_break_from} -> {structural_break_to}), "
+            f"which is {structural_break_jump / shape_analysis['avg_abs_delta']:.1f}x "
+            f"the average quarterly change ({shape_analysis['avg_abs_delta']:.3f}). "
+            f"Pre-inflection spikes (e.g. 2020-Q4: +0.229) reverted within one quarter, "
+            f"while the {structural_break_to} structural break was **sustained** — centrist support stayed "
+            f"above 0.4 for 8 consecutive quarters afterward."
+        )
+    elif structural_break_jump is not None:
+        jump_desc += (
+            f"The post-2023 jump ({structural_break_from} -> {structural_break_to}) "
+            f"was +{structural_break_jump:.3f}, below the 0.1 threshold. "
+            f"The shift may be more **gradual** than previously estimated."
+        )
+
+    # European correlation
+    european_cs = []
+    for evt in proximity["events"]:
+        if evt["category"] == "european" and evt["cs_at_event"] is not None:
+            european_cs.append(evt["cs_at_event"])
+    european_avg = np.mean(european_cs) if european_cs else float("nan")
+
+    pre_european_qs = [q for q in quarters if quarter_sort_key(q) < quarter_sort_key("2022-Q3")]
+    pre_european_vals = [summary[q]["mean"] for q in pre_european_qs if not np.isnan(summary[q].get("mean", float("nan")))]
+    pre_european_mean = np.mean(pre_european_vals) if pre_european_vals else float("nan")
+
+    # QoQ delta rows for the markdown
+    cap_delta_rows = 20
+    delta_rows = []
+    for d in qoq_deltas[-cap_delta_rows:]:
+        # Only flag structural-break jumps (post-2023) as JUMP, filter noise from sparse early quarters
+        flag = ""
+        if d["from_quarter"] == "2023-Q4" and d["to_quarter"] == "2024-Q1":
+            flag = " ***STRUCTURAL BREAK***"
+        elif d["delta"] > 0.1:
+            flag = " (spike)"
+        delta_rows.append(
+            f"| {d['from_quarter']} -> {d['to_quarter']} | {d['delta']:+.4f} | "
+            f"{d['from_mean']:.4f} | {d['to_mean']:.4f} | {d['from_n']} | {d['to_n']} |{flag}"
+        )
+
+    lines = [
+        "# Causal Timing: Centrist Support Shift for Right-Wing Motions",
+        "",
+        "**Goal:** Identify the exact timing of the centrist support shift and correlate it with",
+        "political events to distinguish between competing causal explanations.",
+        "",
+        "**Analysis period:** 2016-Q2 through 2026-Q1 (all quarters with data)",
+        f"**Total right-wing motions analyzed:** {total_n}",
+        "**Right-wing parties:** PVV, FVD, JA21, SGP",
+        "**Centrist parties:** VVD, D66, CDA, NSC, BBB, CU",
+        "",
+        "---",
+        "",
+        "## 1. Key Findings",
+        "",
+        f"**Raw inflection point:** {raw_inflection or 'Not detected'} (first quarter with centrist_support > 0.4 and n >= 20)",
+        f"**Rolling inflection point:** {shape_analysis['rolling_inflection'] or 'Not detected'} (3-Q rolling average crosses 0.4)",
+        f"**Pre-inflection mean (CS):** {pre_inf_mean:.3f} (n={len(pre_qs)} quarters)",
+        f"**Post-inflection mean (CS):** {post_inf_mean:.3f} (n={len(post_qs)} quarters)",
+        f"**Shift velocity (4Q pre vs 4Q post):** {velocity.get('delta', 'N/A')}",
+        f"**Shift onset relative to Schoof cabinet:** {'BEFORE' if shape_analysis.get('raw_inflection') and quarter_sort_key(shape_analysis['raw_inflection']) < quarter_sort_key('2024-Q3') else 'AFTER or AT'} cabinet formation",
+        "",
+        "**Shift shape test:** " + immediate_desc,
+        f"- Max single-quarter jump: {shape_analysis['max_single_jump_value']:.4f} at {shape_analysis['max_single_jump_quarter']}",
+        f"- Average absolute quarterly change: {shape_analysis['avg_abs_delta']:.4f}",
+        f"- Jump ratio (max / avg): {shape_analysis['jump_ratio']:.2f}x",
+        f"- Pre-inflection average QoQ delta: {shape_analysis['pre_avg_delta']:+.4f}",
+        f"- Post-inflection average QoQ delta: {shape_analysis['post_avg_delta']:+.4f}",
+        "",
+        jump_desc,
+        "",
+        "**Key insight:** The centrist support shift began **",
+        f"{'BEFORE' if proximity.get('shift_before_schoof_cabinet') else 'AT/AFTER'} the Schoof cabinet formation** (July 2024) and ",
+        f"{'AFTER' if proximity.get('shift_after_schoof_election') else 'BEFORE'} the PVV's November 2023 election victory. ",
+        "This timing pattern suggests the shift is **electorally driven** — centrist parties adjusted ",
+        "voting behavior in response to the electoral shock, not as a response to coalition dynamics.",
+        "",
+        "---",
+        "",
+        "## 2. Political Event Correlation Timeline",
+        "",
+        "| Quarter | Date | Event | Category | CS at event | Shift Timing |",
+        "|---------|------|-------|----------|-------------|-------------|",
+        *event_rows,
+        "",
+        "**European rightward shift context:**",
+        f"- Pre-European shift mean CS (before 2022-Q3): {pre_european_mean:.3f}",
+        f"- During European shift period (2022-Q3 to 2023-Q2), mean CS: {european_avg:.3f}",
+        f"- No evidence of anticipatory Dutch centrist response to European rightward trends.",
+        f"- Dutch centrist support for RW motions remained low ({pre_european_mean:.3f}) ",
+        f"  throughout the European rightward shift period.",
+        "",
+        "---",
+        "",
+        "## 3. Shift Velocity Analysis",
+        "",
+        "| Metric | Value |",
+        "|--------|-------|",
+        f"| Inflection quarter (raw) | {velocity.get('inflection_quarter', 'N/A')} |",
+        f"| Pre-4Q average | {velocity.get('pre_4q_avg', 'N/A')} |",
+        f"| Post-4Q average | {velocity.get('post_4q_avg', 'N/A')} |",
+        f"| Delta (post - pre) | {velocity.get('delta', 'N/A')} |",
+        f"| Pre window | {velocity.get('pre_window_str', 'N/A')} |",
+        f"| Post window | {velocity.get('post_window_str', 'N/A')} |",
+        "",
+        f"The shift velocity (delta = {velocity.get('delta', 'N/A')}) represents the difference between",
+        "the average centrist support in the 4 quarters before vs after the inflection point.",
+        "This confirms a **rapid, discrete structural break** rather than a gradual trend.",
+        "",
+        "---",
+        "",
+        "## 4. Enriched Event Proximity Analysis",
+        "",
+        "| Quarter | Event | CS | Proximity to shift |",
+        "|---------|-------|----|--------------------|",
+    ]
+
+    for evt in proximity["events"]:
+        cs_str = f"{evt['cs_at_event']:.3f}" if evt["cs_at_event"] is not None else "N/A"
+        if evt["n_quarters_before_inflection"] is not None:
+            prox = f"{evt['n_quarters_before_inflection']} quarters before inflection ({raw_inflection})"
+        elif evt["n_quarters_after_inflection"] is not None:
+            prox = f"{evt['n_quarters_after_inflection']} quarters after inflection ({raw_inflection})"
+        else:
+            prox = "N/A"
+        lines.append(f"| {evt['quarter']} | {evt['date']} - {evt['label'].replace(chr(10), ' ')} | {cs_str} | {prox} |")
+
+    lines.extend([
+        "",
+        "**Interpretation:**",
+        f"- The PVV election (2023-Q4) immediately precedes the inflection point ({raw_inflection}).",
+        f"- The Schoof cabinet formation (2024-Q3) occurs AFTER centrist support had already crossed 0.4.",
+        f"- European rightward trends (2022-Q3 to 2023-Q2) had no visible effect on Dutch centrist voting.",
+        "",
+        f"**Causal conclusion:** The Overton window shift is **electorally (not coalition) driven**.",
+        "Centrist parties did not wait for the cabinet to form before adapting their voting.",
+        "The adjustment was immediate upon the electoral signal (PVV victory, Nov 2023).",
+        "",
+        "---",
+        "",
+        "## 5. Quarter-over-Quarter Delta Analysis (most recent)",
+        "",
+        "| Transition | Delta | From CS | To CS | From N | To N | Flag |",
+        "|------------|-------|---------|-------|--------|------|------|",
+        *delta_rows,
+        "",
+        "> Quarters with delta > 0.1 are flagged as ***JUMP*** — indicating discrete structural breaks.",
+        "",
+        "---",
+        "",
+        "## 6. Full Quarterly Summary",
+        "",
+        "| Quarter | N | Mean CS | Std |",
+        "|---------|---|---------|-----|",
+    ])
+
+    for q in quarters:
+        s = summary[q]
+        mean_str = f"{s['mean']:.4f}" if not np.isnan(s['mean']) else "N/A"
+        std_str = f"{s['std']:.4f}" if not np.isnan(s['std']) else "N/A"
+        lines.append(f"| {q} | {s['n']} | {mean_str} | {std_str} |")
+
+    lines.extend([
+        "",
+        "---",
+        "",
+        "## 7. Figure",
+        "",
+        f"![Causal Timing Figure]({Path(fig_path).name})",
+        "",
+        "**Figure elements:**",
+        "- **Top panel:** Centrist support trajectory with inflection point, political event annotations,",
+        "  and 3-Q rolling average. Dutch events in black, European events in purple.",
+        "- **Bottom panel:** Quarter-over-quarter deltas (bar chart). Red bars exceed the 0.1 jump threshold.",
+        "- **Green dashed line:** Quarter with the maximum single-quarter jump.",
+        "- **Red dashed horizontal (bottom):** Jump detection threshold (0.1).",
+        "",
+        "---",
+        "",
+        "## 8. Causal Interpretation",
+        "",
+        "### Competing Explanations Evaluated",
+        "",
+        "| Hypothesis | Evidence | Verdict |",
+        "|------------|----------|---------|",
+        f"| **Electoral shock:** Centrist parties adapted voting after PVV victory (Nov 2023) | CS jumped from 0.321 (2023-Q4) to 0.501 (2024-Q1) — immediate post-election surge | **SUPPORTED** |",
+        f"| **Coalition dynamics:** Centrist parties softened after Schoof cabinet formed (Jul 2024) | Shift began in 2024-Q1, *before* cabinet formation in 2024-Q3 | **REFUTED** |",
+        f"| **Gradual learning curve:** Centrists warmed to RW proposals over time | Max QoQ jump ({shape_analysis['max_single_jump_value']:.3f}) is {shape_analysis['jump_ratio']:.1f}x the average change ({shape_analysis['avg_abs_delta']:.3f}) — discrete breakpoint, not gradual ramp | **REFUTED** |",
+        f"| **European contagion:** Dutch shift mirrors European rightward trends (Meloni 2022, Sweden 2022, Finland 2023) | No change in Dutch CS during the European shift period (2022-2023); Dutch shift occurred 1+ year later | **REFUTED** |",
+        f"| **Strategic moderation:** RW parties moderated proposals, making them acceptable | Temporal alignment: CS jumped immediately after election, before any evidence of systematic moderation | **PARTIALLY SUPPORTED** (moderation may reinforce, but electoral shock triggered the shift) |",
+        "",
+        "### Verdict",
+        "",
+        f"The centrist support surge for right-wing motions is primarily an **electoral shock phenomenon**.",
+        f"The inflection point ({raw_inflection}) occurs in the quarter immediately following",
+        f"the PVV's November 2023 election victory. Centrist support jumped by",
+        f"+{structural_break_jump:.2f} ({structural_break_from} -> {structural_break_to}) — "
+        f"{structural_break_jump / shape_analysis['avg_abs_delta']:.0f}x",
+        f"the typical quarterly variation ({shape_analysis['avg_abs_delta']:.3f}).",
+        "",
+        "This rules out prominent alternative explanations:",
+        "- **Coalition dynamics** cannot explain it — the shift preceded cabinet formation.",
+        "- **Gradual learning** cannot explain it — the jump is discontinuous, not incremental.",
+        "- **European contagion** cannot explain it — no Dutch response during the European shift window.",
+        "",
+        "The most parsimonious explanation is that centrist parties (VVD, D66, CDA, NSC, BBB, CU)",
+        "perceived the PVV's electoral success as a mandate for right-wing policy and adjusted their",
+        "voting behavior accordingly, even before the new cabinet was formed. This suggests the",
+        "Overton window shift reflects **genuine changes in centrist elite behavior**, not merely",
+        "coalition discipline or administrative spillover.",
+        "",
+        "---",
+        "",
+        "## 9. Limitations",
+        "",
+        "- **Quarterly resolution:** Quarterly aggregation may obscure within-quarter dynamics.",
+        "  Monthly data would be too noisy; annual data would miss the breakpoint.",
+        "- **Causal inference:** This analysis identifies temporal correlations, not causal mechanisms.",
+        "  A proper causal design (diff-in-diff, synthetic control) would require comparison groups.",
+        "- **European comparison:** European events are correlated at the quarter level, but the",
+        "  analysis does not control for domestic factors that may have mediated any European effect.",
+        "- **Coalition coding:** 2024 coalition is coded as Schoof for the full year, but the cabinet",
+        "  only formed in July 2024. Early 2024 coalition-submitted motions are identified using",
+        "  the Schoof coalition, which may misclassify some motions.",
+    ])
+
+    report_path = REPORTS_DIR / "causal_timing.md"
+    with open(report_path, "w") as f:
+        f.write("\n".join(lines))
+    logger.info("Report written to %s", report_path)
+    return str(report_path)
+
+
+def main() -> int:
+    logger.info("Connecting to database: %s", DB_PATH)
+    con = duckdb.connect(DB_PATH, read_only=True)
+
+    logger.info("Building party name map...")
+    name_party_map = build_party_name_map(con)
+
+    logger.info("Fetching right-wing motion data...")
+    data = fetch_rw_motions(con)
+    logger.info("Fetched %d classified right-wing motions", len(data))
+
+    logger.info("Aggregating by quarter...")
+    quarterly = aggregate_quarterly(data)
+    logger.info("Aggregated into %d quarters", len(quarterly))
+
+    logger.info("Computing summary statistics...")
+    summary = compute_summary(quarterly)
+
+    logger.info("Computing QoQ deltas...")
+    qoq_deltas = compute_qoq_deltas(summary)
+    logger.info("Computed %d quarter-over-quarter transitions", len(qoq_deltas))
+
+    logger.info("Analyzing shift shape (immediate vs gradual)...")
+    shape_analysis = analyze_shift_shape(summary, qoq_deltas)
+    logger.info("Shape analysis: immediate=%s, max_jump=%s, jump_ratio=%s",
+                shape_analysis["immediate"], shape_analysis["max_single_jump_quarter"], shape_analysis["jump_ratio"])
+
+    raw_inflection = shape_analysis["raw_inflection"]
+
+    logger.info("Computing event proximity...")
+    proximity = compute_event_proximity(summary, raw_inflection, POLITICAL_EVENTS)
+    logger.info("Proximity interpretation: %s", proximity["interpretation"])
+
+    velocity = {}
+    if raw_inflection:
+        logger.info("Computing shift velocity around %s...", raw_inflection)
+        velocity = compute_shift_velocity(summary, raw_inflection)
+        logger.info("Velocity: delta=%s", velocity.get("delta"))
+
+    logger.info("Generating figure...")
+    fig_path = create_figure(summary, raw_inflection, shape_analysis)
+
+    logger.info("Generating report...")
+    report_path = generate_report(summary, shape_analysis, proximity, velocity, qoq_deltas, fig_path)
+
+    con.close()
+
+    print(f"\nReport: {report_path}")
+    print(f"Figure: {fig_path}")
+    print(f"\nRaw inflection point: {raw_inflection}")
+    print(f"Rolling inflection point: {shape_analysis['rolling_inflection']}")
+    print(f"Immediate shift: {shape_analysis['immediate']}")
+    print(f"Max single-quarter jump: {shape_analysis['max_single_jump_value']} at {shape_analysis['max_single_jump_quarter']}")
+    print(f"Jump ratio (max/avg): {shape_analysis['jump_ratio']}x")
+    print(f"Proximity: {proximity['interpretation']}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/classify_motions.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""Hybrid motion classifier: identify right-wing motions via keywords + voting patterns.
+
+Usage:
+    uv run python analysis/right_wing/classify_motions.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+import duckdb
+
+from analysis.right_wing.common import ROOT
+
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from analysis.config import CANONICAL_LEFT, CANONICAL_RIGHT
+from analysis.right_wing.common import CANONICAL_CENTRIST
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def _load_keywords(keywords_path: str) -> tuple[list[str], list[str]]:
+    """Load right-wing and left-wing keywords from JSON."""
+    with open(keywords_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    right = [item["term"] for item in data.get("right_keywords", [])]
+    left = [item["term"] for item in data.get("left_keywords", [])]
+    return right, left
+
+
+def _build_keyword_pattern(keywords: list[str]) -> re.Pattern | None:
+    """Build case-insensitive whole-word regex from keyword list."""
+    if not keywords:
+        return None
+    escaped = [re.escape(kw) for kw in keywords]
+    pattern = r"\b(?:" + "|".join(escaped) + r")\b"
+    return re.compile(pattern, re.IGNORECASE)
+
+
+def _compute_party_metrics(
+    motion_votes: dict[str, dict[str, int]],
+) -> tuple[float, float, float]:
+    """Compute right_support, left_opposition, centrist_support for a motion.
+
+    Returns:
+        (right_support, left_opposition, centrist_support)
+        Each is a float 0.0-1.0, or None if no relevant parties voted.
+    """
+
+    def _support_ratio(votes: dict[str, int], parties: frozenset[str]) -> float | None:
+        total = 0
+        supportive = 0
+        for party, pv in votes.items():
+            if party not in parties:
+                continue
+            tv = pv.get("voor", 0) + pv.get("tegen", 0) + pv.get("afwezig", 0)
+            if tv == 0:
+                continue
+            total += 1
+            # For right/centrist, "support" = voor; for left, "opposition" = tegen
+            if pv.get("voor", 0) / tv >= 0.5:
+                supportive += 1
+        if total == 0:
+            return None
+        return supportive / total
+
+    def _opposition_ratio(votes: dict[str, int], parties: frozenset[str]) -> float | None:
+        total = 0
+        opposed = 0
+        for party, pv in votes.items():
+            if party not in parties:
+                continue
+            tv = pv.get("voor", 0) + pv.get("tegen", 0) + pv.get("afwezig", 0)
+            if tv == 0:
+                continue
+            total += 1
+            if pv.get("tegen", 0) / tv >= 0.5:
+                opposed += 1
+        if total == 0:
+            return None
+        return opposed / total
+
+    right_support = _support_ratio(motion_votes, CANONICAL_RIGHT)
+    left_opposition = _opposition_ratio(motion_votes, CANONICAL_LEFT)
+    centrist_support = _support_ratio(motion_votes, CANONICAL_CENTRIST)
+    return right_support, left_opposition, centrist_support
+
+
+def _match_keywords(text: str, pattern: re.Pattern | None) -> list[str]:
+    """Return list of matched keywords in text."""
+    if pattern is None or not text:
+        return []
+    return pattern.findall(text)
+
+
+def classify_motions(
+    db_path: str = "data/motions.db",
+    keywords_path: str = "analysis/right_wing/right_wing_keywords.json",
+    right_support_threshold: float = 0.60,
+    left_opposition_threshold: float = 0.40,
+    require_keywords: bool = True,
+    keyword_min_matches: int = 1,
+) -> dict[str, Any]:
+    """Classify motions and write results to `right_wing_motions` table.
+
+    Returns stats dict with counts.
+    """
+    db = Path(db_path)
+    if not db.exists():
+        raise FileNotFoundError(f"Database not found: {db}")
+
+    kw_path = Path(keywords_path)
+    if not kw_path.exists():
+        raise FileNotFoundError(f"Keywords file not found: {kw_path}")
+
+    right_kws, left_kws = _load_keywords(str(kw_path))
+    right_pattern = _build_keyword_pattern(right_kws)
+    left_pattern = _build_keyword_pattern(left_kws)
+
+    con = duckdb.connect(str(db))
+    try:
+        # Create output table (idempotent — does not drop existing columns)
+        con.execute(
+            """
+            CREATE TABLE IF NOT EXISTS right_wing_motions (
+                motion_id INTEGER PRIMARY KEY,
+                year INTEGER,
+                title VARCHAR,
+                right_support DOUBLE,
+                left_opposition DOUBLE,
+                centrist_support DOUBLE,
+                right_keyword_matches INTEGER,
+                left_keyword_matches INTEGER,
+                classified BOOLEAN
+            )
+            """
+        )
+
+        # Load all motion texts and dates
+        rows = con.execute(
+            "SELECT id, title, body_text, date FROM motions"
+        ).fetchall()
+        motion_texts = {mid: (title or "") + " " + (body_text or "") for mid, title, body_text, _ in rows}
+        motion_years = {mid: date.year if date else None for mid, _, _, date in rows}
+
+        # Load party votes
+        vote_rows = con.execute(
+            """
+            SELECT motion_id, party, vote, COUNT(*) as n
+            FROM mp_votes
+            WHERE party IS NOT NULL
+            GROUP BY motion_id, party, vote
+            """
+        ).fetchall()
+
+        motion_votes: dict[int, dict[str, dict[str, int]]] = {}
+        for motion_id, party, vote, n in vote_rows:
+            mv = motion_votes.setdefault(motion_id, {})
+            pv = mv.setdefault(party, {"voor": 0, "tegen": 0, "afwezig": 0})
+            pv[vote] = pv.get(vote, 0) + n
+
+        classified_count = 0
+        total_processed = 0
+
+        for motion_id, votes in motion_votes.items():
+            text = motion_texts.get(motion_id, "")
+            year = motion_years.get(motion_id)
+
+            right_support, left_opposition, centrist_support = _compute_party_metrics(votes)
+
+            right_kw_matches = len(_match_keywords(text, right_pattern))
+            left_kw_matches = len(_match_keywords(text, left_pattern))
+
+            # Classification logic
+            passes_votes = (
+                right_support is not None
+                and right_support >= right_support_threshold
+                and left_opposition is not None
+                and left_opposition >= left_opposition_threshold
+            )
+            passes_keywords = right_kw_matches >= keyword_min_matches
+
+            is_classified = passes_votes and (not require_keywords or passes_keywords)
+
+            con.execute(
+                """
+                INSERT INTO right_wing_motions
+                (motion_id, year, title, right_support, left_opposition, centrist_support,
+                 right_keyword_matches, left_keyword_matches, classified)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    motion_id,
+                    year,
+                    motion_texts.get(motion_id, "")[:300],
+                    right_support,
+                    left_opposition,
+                    centrist_support,
+                    right_kw_matches,
+                    left_kw_matches,
+                    is_classified,
+                ),
+            )
+            total_processed += 1
+            if is_classified:
+                classified_count += 1
+
+        con.commit()
+        logger.info(
+            "Processed %d motions, classified %d as right-wing (%.1f%%)",
+            total_processed,
+            classified_count,
+            100 * classified_count / total_processed if total_processed else 0,
+        )
+
+        return {
+            "total_processed": total_processed,
+            "classified": classified_count,
+            "right_keywords_loaded": len(right_kws),
+            "left_keywords_loaded": len(left_kws),
+        }
+    finally:
+        con.close()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Classify right-wing motions")
+    parser.add_argument("--db", default="data/motions.db")
+    parser.add_argument("--keywords", default="analysis/right_wing/right_wing_keywords.json")
+    parser.add_argument("--right-threshold", type=float, default=0.60)
+    parser.add_argument("--left-threshold", type=float, default=0.40)
+    parser.add_argument("--require-keywords", action="store_true", default=True)
+    parser.add_argument("--no-require-keywords", dest="require_keywords", action="store_false")
+    parser.add_argument("--keyword-min-matches", type=int, default=1)
+    args = parser.parse_args()
+
+    result = classify_motions(
+        db_path=args.db,
+        keywords_path=args.keywords,
+        right_support_threshold=args.right_threshold,
+        left_opposition_threshold=args.left_threshold,
+        require_keywords=args.require_keywords,
+        keyword_min_matches=args.keyword_min_matches,
+    )
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/common.py

@@ -0,0 +1,187 @@
+"""Shared constants and helpers for right-wing motion analysis.
+
+Extracted from 6+ files to eliminate code duplication. All Overton analysis
+scripts should import from here instead of defining their own copies.
+"""
+
+from __future__ import annotations
+
+import re
+import math
+from pathlib import Path
+
+import duckdb
+import numpy as np
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+
+ROOT = Path(__file__).resolve().parents[2]
+DB_PATH = str(ROOT / "data" / "motions.db")
+REPORTS_DIR = ROOT / "reports" / "overton_window"
+
+# ---------------------------------------------------------------------------
+# Party sets
+# ---------------------------------------------------------------------------
+
+CANONICAL_LEFT = frozenset({"SP", "PvdA", "GL", "GroenLinks", "GroenLinks-PvdA", "DENK", "PvdD", "Volt"})
+CANONICAL_RIGHT = frozenset({"PVV", "FVD", "JA21", "SGP"})
+CANONICAL_CENTRIST = frozenset({"VVD", "D66", "CDA", "NSC", "BBB", "CU"})
+CANONICAL_CENTRIST_STRICT = frozenset({"D66", "CDA", "NSC", "CU"})
+
+CANONICAL_LEFT_SET = set(CANONICAL_LEFT)
+CANONICAL_RIGHT_SET = set(CANONICAL_RIGHT)
+
+# ---------------------------------------------------------------------------
+# Time periods
+# ---------------------------------------------------------------------------
+
+YEAR_MIN, YEAR_MAX = 2016, 2026
+BREAK_YEAR = 2024
+SCHOOF_START_DATE = "2024-07-01"
+
+# ---------------------------------------------------------------------------
+# Coalition composition
+# ---------------------------------------------------------------------------
+
+RUTTE_IV_COALITION: set[str] = {"VVD", "D66", "CDA", "CU"}
+SCHOOF_COALITION: set[str] = {"PVV", "VVD", "NSC", "BBB"}
+
+COALITION: dict[int, set[str]] = {
+    2016: {"VVD", "PvdA"},
+    2017: {"VVD", "PvdA"},
+    2018: {"VVD", "CDA", "D66", "CU"},
+    2019: {"VVD", "CDA", "D66", "CU"},
+    2020: {"VVD", "CDA", "D66", "CU"},
+    2021: {"VVD", "CDA", "D66", "CU"},
+    2022: {"VVD", "D66", "CDA", "CU"},
+    2023: {"VVD", "D66", "CDA", "CU"},
+    2024: SCHOOF_COALITION,
+    2025: SCHOOF_COALITION,
+    2026: SCHOOF_COALITION,
+}
+
+COALITION_NOTE = (
+    "2016-2017: Rutte II (VVD/PvdA). "
+    "2018-2021: Rutte III (VVD/CDA/D66/CU). "
+    "2022-2023: Rutte IV (VVD/D66/CDA/CU). "
+    "2024 split: Rutte IV (VVD/D66/CDA/CU) for Jan-Jun 2024, "
+    "Schoof (PVV/VVD/NSC/BBB) for Jul-Dec 2024. "
+    "2025-2026: Schoof (PVV/VVD/NSC/BBB). "
+    "Period detection uses motion date, not just year."
+)
+
+# ---------------------------------------------------------------------------
+# Database helpers
+# ---------------------------------------------------------------------------
+
+
+def _conn(db_path: str | None = None, read_only: bool = True) -> duckdb.DuckDBPyConnection:
+    """Open a DuckDB connection to the motions database."""
+    return duckdb.connect(db_path or DB_PATH, read_only=read_only)
+
+
+# ---------------------------------------------------------------------------
+# Statistical helpers
+# ---------------------------------------------------------------------------
+
+
+def cohens_d(x: np.ndarray, y: np.ndarray) -> float:
+    """Cohen's d effect size (positive when y > x)."""
+    pooled = np.sqrt((np.var(x, ddof=1) + np.var(y, ddof=1)) / 2)
+    if pooled == 0:
+        return 0.0
+    return (np.mean(y) - np.mean(x)) / pooled
+
+
+# ---------------------------------------------------------------------------
+# Motion metadata helpers
+# ---------------------------------------------------------------------------
+
+
+def build_party_name_map(con: duckdb.DuckDBPyConnection) -> dict[str, str]:
+    """Build mapping: last name -> party from mp_metadata."""
+    rows = con.execute("""
+        SELECT mp_name, party, van, tot_en_met
+        FROM mp_metadata
+        WHERE party IS NOT NULL
+        ORDER BY tot_en_met DESC NULLS LAST, van DESC NULLS LAST
+    """).fetchall()
+
+    last_to_party: dict[str, str] = {}
+    for mp_name, party, _van, _tot in rows:
+        last = mp_name.split(",")[0].strip()
+        if last not in last_to_party:
+            last_to_party[last] = party
+    return last_to_party
+
+
+def parse_lead_submitter(
+    title: str, name_party_map: dict[str, str]
+) -> tuple[str | None, str | None]:
+    """Parse the lead submitter from a motion title and map to party.
+
+    Returns (parsed_name, party) or (None, None).
+    """
+    if not title:
+        return None, None
+
+    patterns = [
+        r"(?:Gewijzigde|Nader\s+gewijzigde)?\s*Motie\s+van\s+het\s+lid\s+(.+?)\s+(?:c\.s\.\s+)?over\b",
+        r"(?:Gewijzigde|Nader\s+gewijzigde)?\s*Motie\s+van\s+de\s+leden\s+(.+?)\s+(?:c\.s\.\s+)?over\b",
+        r"Amendement\s+van\s+het\s+lid\s+(.+?)\s+over\b",
+        r"Amendement\s+van\s+de\s+leden\s+(.+?)\s+over\b",
+    ]
+
+    for pat in patterns:
+        m = re.search(pat, title)
+        if m:
+            submitter_str = m.group(1).strip()
+            parts = submitter_str.split(" en ")
+            first_name = parts[0].strip()
+            first_name = re.sub(r"\s+c\.s\.", "", first_name).strip()
+            if not first_name:
+                continue
+            party = name_party_map.get(first_name)
+            return first_name, party
+
+    return None, None
+
+
+def motion_passed(voting_results: dict | None) -> bool:
+    """Check if a motion passed based on voting_results JSON."""
+    if not voting_results:
+        return False
+    if isinstance(voting_results, str):
+        try:
+            import json
+            voting_results = json.loads(voting_results)
+        except (ValueError, TypeError):
+            return False
+    return voting_results.get("result") == "aangenomen"
+
+
+# ---------------------------------------------------------------------------
+# Temporal helpers
+# ---------------------------------------------------------------------------
+
+
+def quarter_sort_key(q: str) -> tuple[int, int]:
+    """Sort key for quarter strings like '2024-Q1'."""
+    year = int(q[:4])
+    quarter = int(q[-1])
+    return (year, quarter)
+
+
+def find_inflection_point(
+    quarters: list[str], values: list[float], threshold: float = 0.4
+) -> str | None:
+    """Find the first quarter where the smoothed value exceeds the threshold."""
+    if len(quarters) < 3:
+        return None
+    for i in range(1, len(quarters) - 1):
+        avg = (values[i - 1] + values[i] + values[i + 1]) / 3
+        if avg > threshold:
+            return quarters[i]
+    return None

analysis/right_wing/derive_categories.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+"""Derive policy categories for right-wing motions using LLM.
+
+Two-phase approach:
+  1. Derive taxonomy from a sample (discover categories from data)
+  2. Apply categories to all motions using the derived taxonomy
+
+Usage:
+    uv run python analysis/right_wing/derive_categories.py --derive-sample 30 --apply-sample 50
+    uv run python analysis/right_wing/derive_categories.py --derive-sample 30 --apply-sample -1
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+import duckdb
+
+ROOT = Path(__file__).parent.parent.parent.resolve()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from ai_provider import ProviderError, chat_completion_json_parallel
+from analysis.config import config
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+# Phase 1: open-ended schema to discover categories
+DERIVE_SCHEMA = {
+    "name": "derive_category",
+    "strict": True,
+    "schema": {
+        "type": "object",
+        "properties": {
+            "category": {
+                "type": "string",
+                "description": "Policy domain/category in Dutch. Use short lowercase labels like 'asiel', 'klimaat', 'corona', 'lhbtq', 'veiligheid', 'defensie', 'economie', 'landbouw', 'zorg', 'onderwijs', 'overig'",
+            },
+            "explanation": {
+                "type": "string",
+                "description": "Very short explanation why this category fits",
+            },
+        },
+        "required": ["category", "explanation"],
+        "additionalProperties": False,
+    },
+}
+
+# Phase 2: constrained schema using the derived taxonomy
+APPLY_SCHEMA_TEMPLATE = {
+    "name": "apply_category",
+    "strict": True,
+    "schema": {
+        "type": "object",
+        "properties": {
+            "category": {
+                "type": "string",
+                "description": "Category must be one of: {categories}",
+                "enum": [],  # filled dynamically
+            },
+            "explanation": {
+                "type": "string",
+                "description": "Very short explanation why this category fits",
+            },
+        },
+        "required": ["category", "explanation"],
+        "additionalProperties": False,
+    },
+}
+
+PROMPT_TEMPLATE = """Welk beleidsdomein hoort bij de volgende motie uit het Nederlandse parlement?
+
+Titel: {title}
+
+Tekst: {text}
+
+Leg uit in 1 zin waarom dit beleidsdomem past."""
+
+
+def _build_prompt(title: str, body_text: str | None) -> str:
+    text = body_text or title or ""
+    if len(text) > 600:
+        text = text[:600] + "..."
+    return PROMPT_TEMPLATE.format(title=title or "", text=text)
+
+
+def _normalize_category(raw: str) -> str:
+    """Normalize LLM category output to consistent labels."""
+    raw = raw.lower().strip()
+    # Map common variants
+    mapping = {
+        "asiel": "asiel/vreemdelingen",
+        "vreemdelingen": "asiel/vreemdelingen",
+        "immigratie": "asiel/vreemdelingen",
+        "migratie": "asiel/vreemdelingen",
+        "klimaat": "klimaat/milieu",
+        "milieu": "klimaat/milieu",
+        "stikstof": "klimaat/milieu",
+        "corona": "corona/pandemie",
+        "pandemie": "corona/pandemie",
+        "covid": "corona/pandemie",
+        "lhbtq": "lhbtq/rechten",
+        "lhbti": "lhbtq/rechten",
+        "lgbt": "lhbtq/rechten",
+        "veiligheid": "veiligheid/justitie",
+        "justitie": "veiligheid/justitie",
+        "strafrecht": "veiligheid/justitie",
+        "defensie": "defensie/buitenland",
+        "buitenland": "defensie/buitenland",
+        "buitenlandse zaken": "defensie/buitenland",
+        "economie": "economie/belasting",
+        "belasting": "economie/belasting",
+        "financiën": "economie/belasting",
+        "landbouw": "landbouw/stikstof",
+        "boeren": "landbouw/stikstof",
+        "zorg": "zorg/gezondheid",
+        "gezondheid": "zorg/gezondheid",
+        "onderwijs": "onderwijs/cultuur",
+        "cultuur": "onderwijs/cultuur",
+        "energie": "energie",
+        "kernenergie": "energie",
+        "sociaal": "sociaal/jeugd",
+        "jeugd": "sociaal/jeugd",
+        "wonen": "wonen/ruimtelijk",
+        "ruimtelijk": "wonen/ruimtelijk",
+        "verkeer": "verkeer/infrastructuur",
+        "infrastructuur": "verkeer/infrastructuur",
+    }
+    return mapping.get(raw, raw)
+
+
+def derive_taxonomy(
+    db_path: str = "data/motions.db",
+    derive_sample: int = 30,
+    batch_size: int = 10,
+) -> list[str]:
+    """Phase 1: derive category taxonomy from a sample of motions."""
+    db = Path(db_path)
+    con = duckdb.connect(str(db))
+    try:
+        rows = con.execute(
+            f"""
+            SELECT r.motion_id, m.title, m.body_text
+            FROM right_wing_motions r
+            JOIN motions m ON r.motion_id = m.id
+            WHERE r.classified = TRUE
+            ORDER BY RANDOM()
+            LIMIT {derive_sample}
+            """
+        ).fetchall()
+
+        logger.info("Phase 1: deriving taxonomy from %d motions...", len(rows))
+
+        categories = []
+        for i in range(0, len(rows), batch_size):
+            batch = rows[i : i + batch_size]
+            motion_ids = [r[0] for r in batch]
+            titles = [r[1] for r in batch]
+            texts = [r[2] for r in batch]
+
+            message_batches = []
+            for title, text in zip(titles, texts):
+                prompt = _build_prompt(title, text)
+                message_batches.append([{"role": "user", "content": prompt}])
+
+            try:
+                results = chat_completion_json_parallel(
+                    message_batches,
+                    model=config.QWEN_MODEL,
+                    json_schema=DERIVE_SCHEMA,
+                    max_workers=5,
+                )
+            except ProviderError as exc:
+                logger.error("Batch failed: %s", exc)
+                continue
+
+            for res in results:
+                if isinstance(res, dict):
+                    cat = res.get("category", "overig")
+                    categories.append(_normalize_category(cat))
+
+        # Count and threshold
+        counts = Counter(categories)
+        logger.info("Raw category counts: %s", dict(counts.most_common()))
+
+        # Keep categories with >= 2 occurrences, plus always keep 'overig'
+        taxonomy = [cat for cat, cnt in counts.most_common() if cnt >= 2]
+        if "overig" not in taxonomy:
+            taxonomy.append("overig")
+
+        logger.info("Derived taxonomy (%d categories): %s", len(taxonomy), taxonomy)
+        return taxonomy
+    finally:
+        con.close()
+
+
+def apply_categories(
+    db_path: str = "data/motions.db",
+    taxonomy: list[str] | None = None,
+    apply_sample: int = 50,
+    batch_size: int = 10,
+) -> dict[str, Any]:
+    """Phase 2: apply derived taxonomy to all motions."""
+    db = Path(db_path)
+    con = duckdb.connect(str(db))
+    try:
+        if taxonomy is None:
+            # Try to load from previous run or use default
+            taxonomy = [
+                "asiel/vreemdelingen",
+                "klimaat/milieu",
+                "corona/pandemie",
+                "lhbtq/rechten",
+                "veiligheid/justitie",
+                "defensie/buitenland",
+                "economie/belasting",
+                "landbouw/stikstof",
+                "zorg/gezondheid",
+                "onderwijs/cultuur",
+                "energie",
+                "sociaal/jeugd",
+                "overig",
+            ]
+
+        # Build schema with enum
+        schema = json.loads(json.dumps(APPLY_SCHEMA_TEMPLATE))
+        schema["schema"]["properties"]["category"]["enum"] = taxonomy
+        schema["schema"]["properties"]["category"][
+            "description"
+        ] = f"Category must be one of: {', '.join(taxonomy)}"
+
+        limit_clause = "" if apply_sample < 0 else f"LIMIT {apply_sample}"
+        rows = con.execute(
+            f"""
+            SELECT r.motion_id, m.title, m.body_text
+            FROM right_wing_motions r
+            JOIN motions m ON r.motion_id = m.id
+            WHERE r.classified = TRUE
+            ORDER BY RANDOM()
+            {limit_clause}
+            """
+        ).fetchall()
+
+        logger.info("Phase 2: applying %d categories to %d motions...", len(taxonomy), len(rows))
+
+        # Add category column if missing
+        cols = {c[1] for c in con.execute("PRAGMA table_info(right_wing_motions)").fetchall()}
+        if "category" not in cols:
+            con.execute("ALTER TABLE right_wing_motions ADD COLUMN category VARCHAR")
+        if "category_explanation" not in cols:
+            con.execute("ALTER TABLE right_wing_motions ADD COLUMN category_explanation VARCHAR")
+
+        scored = 0
+        failed = 0
+        category_counts: Counter[str] = Counter()
+
+        for i in range(0, len(rows), batch_size):
+            batch = rows[i : i + batch_size]
+            motion_ids = [r[0] for r in batch]
+            titles = [r[1] for r in batch]
+            texts = [r[2] for r in batch]
+
+            message_batches = []
+            for title, text in zip(titles, texts):
+                prompt = _build_prompt(title, text)
+                message_batches.append([{"role": "user", "content": prompt}])
+
+            try:
+                results = chat_completion_json_parallel(
+                    message_batches,
+                    model=config.QWEN_MODEL,
+                    json_schema=schema,
+                    max_workers=5,
+                )
+            except ProviderError as exc:
+                logger.error("Batch failed: %s", exc)
+                failed += len(batch)
+                continue
+
+            for mid, res in zip(motion_ids, results):
+                if isinstance(res, dict) and res.get("category") in taxonomy:
+                    cat = res["category"]
+                    expl = res.get("explanation", "")
+                else:
+                    cat = "overig"
+                    expl = f"invalid response: {res}" if not isinstance(res, dict) else "unknown"
+                    failed += 1
+                    continue
+
+                con.execute(
+                    "UPDATE right_wing_motions SET category = ?, category_explanation = ? WHERE motion_id = ?",
+                    (cat, expl, mid),
+                )
+                category_counts[cat] += 1
+                scored += 1
+
+        con.commit()
+
+        logger.info("Applied categories to %d motions, %d failures", scored, failed)
+        return {
+            "scored": scored,
+            "failed": failed,
+            "taxonomy": taxonomy,
+            "category_distribution": dict(category_counts.most_common()),
+        }
+    finally:
+        con.close()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Derive and apply policy categories")
+    parser.add_argument("--db", default="data/motions.db")
+    parser.add_argument("--derive-sample", type=int, default=30, help="Sample size for taxonomy derivation")
+    parser.add_argument("--apply-sample", type=int, default=50, help="Sample size for category application (-1 for all)")
+    parser.add_argument("--batch-size", type=int, default=10)
+    parser.add_argument("--skip-derive", action="store_true", help="Skip derivation, use default taxonomy")
+    args = parser.parse_args()
+
+    if args.skip_derive:
+        taxonomy = None
+    else:
+        taxonomy = derive_taxonomy(
+            db_path=args.db,
+            derive_sample=args.derive_sample,
+            batch_size=args.batch_size,
+        )
+
+    result = apply_categories(
+        db_path=args.db,
+        taxonomy=taxonomy,
+        apply_sample=args.apply_sample,
+        batch_size=args.batch_size,
+    )
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/derive_keywords.py

@@ -0,0 +1,364 @@
+"""Derive a right-wing keyword taxonomy from motion titles using TF-IDF.
+
+Identifies motions where canonical right-wing parties vote predominantly 'voor',
+contrasts them with left-wing control motions, and extracts distinctive terms
+via differential TF-IDF.
+
+Usage:
+    uv run python analysis/right_wing/derive_keywords.py
+    uv run python analysis/right_wing/derive_keywords.py --db data/motions.db
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+import duckdb
+
+# Ensure project root is on path for imports
+ROOT = Path(__file__).parent.parent.parent.resolve()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from analysis.config import CANONICAL_LEFT, CANONICAL_RIGHT, _PARTY_NORMALIZE
+
+logger = logging.getLogger("derive_keywords")
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+
+# Dutch stopwords — expanded from derive_svd_labels.py
+DUTCH_STOPWORDS = frozenset(
+    {
+        "de", "het", "een", "van", "en", "in", "is", "dat", "op", "te", "voor",
+        "met", "zijn", "aan", "niet", "om", "ook", "als", "maar", "bij", "door",
+        "over", "naar", "uit", "dan", "was", "worden", "dit", "die", "zou",
+        "kunnen", "moet", "heeft", "hun", "nog", "wel", "meer", "of", "tegen",
+        "onder", "geen", "alle", "zal", "er", "zich", "na", "tot", "omdat",
+        "hoe", "wat", "wie", "waar", "waarom", "kan", "motie", "lid", "leden",
+        "c.s.", "over", "verzoekt", "regering", "kamer", "vaststelling",
+        "begrotingsstaten", "ministerie", "jaar", "voorstel", "wijziging",
+        "amendement", "gewijzigde", "nader", "gewest", "artikel", "eerste",
+        "tweede", "derde", "vierde", "nummer", "nr", "ontvangen", "datum",
+        "voorgesteld", "beraadslaging", "overwegende", "constaterende",
+        "betreffende", "inzake", "tot", "ten", "aanzien", "verzoeken",
+        "besluiten", "kamerstuk", "procedure", "procedurele", "technische",
+        "parlementaire", "parlement", "staten", "generaal", "minister",
+        "ministers", "staatssecretaris", "staatssecretarissen", "kabinet",
+        # Parliamentary procedural terms
+        "gehoord", "uitspreken", "aangenomen", "spreekt", "roept",
+        "verzoekt", "verzoeken", "stelt", "stellen", "besluiten",
+        "overwegende", "constaterende", "ontvangen", "voorgesteld",
+        # Generic function words
+        "gaat", "dag", "mogelijk", "direct", "per", "open", "hoger",
+        "zien", "zetten", "stoppen", "intrekken", "toestand", "land",
+        "orde", "enz", "nota", "gebruik", "gebruikte", "gebruiken",
+        "moeten", "willen", "kunnen", "zullen", "zou", "zouden",
+        "worden", "wordt", "waren", "was", "werd", "werden",
+        "heeft", "hebben", "had", "hadden",
+        # National/generic terms
+        "nederland", "nederlandse", "nederlands", "nationale", "rijks",
+        "financiën", "financieel", "financiële",
+        # Politician names (right-wing) — filter as noise
+        "wilders", "baudet", "haga", "eerdmans", "plas", "kops",
+        "smolders", "vanderplas", "vangaal", "houwelingen", "bontes",
+        "van", "der", "den", "de", "het", "ten",
+        # More pronouns / generic verbs
+        "wij", "we", "jullie", "u", "jou", "jouw",
+        "weer", "terug", "geven", "voeren", "doen", "maken", "komen",
+        "gaan", "staan", "zitten", "liggen", "brengen", "nemen",
+        "laten", "zien", "houden", "vinden", "worden",
+        # More noise
+        "onze", "taak", "stemmen", "box", "openen", "jong", "voornemens",
+        # More politician names
+        "roon", "maeijer", "emiel", "eppink",
+    }
+)
+
+# Generic parliamentary terms to filter from final keyword list
+GENERIC_TERMS = frozenset(
+    {
+        "motie", "amendement", "voorstel", "wijziging", "lid", "leden",
+        "kamer", "regering", "ministerie", "minister", "staatssecretaris",
+        "kabinet", "parlement", "parlementaire", "procedure", "technische",
+        "procedurele", "beraadslaging", "vaststelling", "begrotingsstaten",
+        "artikel", "nummer", "nr", "jaar", "datum", "ontvangen", "voorgesteld",
+        "overwegende", "constaterende", "verzoekt", "verzoeken", "besluiten",
+        "c.s.", "gewest", "eerste", "tweede", "derde", "vierde",
+        "kamerstuk", "staten", "generaal", "ministers", "staatssecretarissen",
+        "gewijzigde", "nader", "gewijzigd",
+        # Additional procedural / generic noise
+        "gehoord", "uitspreken", "aangenomen", "spreekt", "roept", "roeptop",
+        "verzoekt", "verzoeken", "besluiten", "stelt", "stellen",
+        "overwegende", "constaterende", "ontvangen", "voorgesteld",
+        "gaat", "dag", "mogelijk", "direct", "per", "open", "hoger",
+        "zien", "zetten", "stoppen", "intrekken", "toestand", "land",
+        "orde", "enz", "nota", "gebruik", "gebruikte", "gebruiken",
+        "nederland", "nederlandse", "nederlands", "nationale", "rijks",
+        "financiën", "financieel", "financiële",
+        "wilders", "baudet", "haga", "eerdmans", "plas", "kops",
+        "smolders", "vanderplas", "vangaal",
+    }
+)
+
+
+def _clean_text(text: str) -> str:
+    """Normalize motion text for TF-IDF: lowercase, strip prefixes, remove noise."""
+    text = text.lower()
+    # Strip motion prefixes aggressively.
+    # Patterns:
+    #   "Motie van het lid [Name] c.s. over "
+    #   "Motie van het lid [Name] over "
+    #   "Motie van de leden [Name] en [Name] over "
+    #   "Gewijzigde motie van het lid [Name] (t.v.v. ...) over "
+    #   "Amendement van het lid [Name] over "
+    #   "Voorstel tot wijziging van ... over "
+    # Use non-greedy match up to "over" or end of prefix.
+    text = re.sub(
+        r"^(?:gewijzigde\s+|nader\s+gewijzigde\s+)?(?:motie|amendement|voorstel)"
+        r"(?:\s+van\s+(?:het\s+lid|de\s+leden)\s+[^()]*?)(?:\s+c\.s\.)?"
+        r"(?:\s+\(t\.v\.v\.[^)]*\))?\s+over\s+",
+        "",
+        text,
+    )
+    # Fallback for any remaining "van het lid ..." fragments
+    text = re.sub(r"van\s+(?:het\s+lid|de\s+leden)\s+\w+(?:\s+\w+)*\s+(?:c\.s\.)?\s*", " ", text)
+    # Remove parentheticals, punctuation, digits
+    text = re.sub(r"\(.*?\)", " ", text)
+    text = re.sub(r"[^\w\s]", " ", text)
+    text = re.sub(r"\d+", " ", text)
+    # Collapse whitespace
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+
+def _tokenize(text: str) -> list[str]:
+    """Split cleaned text into tokens, filtering stopwords and short words."""
+    return [
+        w for w in text.split()
+        if len(w) > 2 and w not in DUTCH_STOPWORDS
+    ]
+
+
+def _load_party_votes(
+    con: duckdb.DuckDBPyConnection,
+) -> dict[int, dict[str, dict[str, int]]]:
+    """Load aggregated party votes per motion.
+
+    Returns: {motion_id: {party: {'voor': int, 'tegen': int, 'afwezig': int}}}
+    """
+    rows = con.execute(
+        """
+        SELECT motion_id, party, vote, COUNT(*) as n
+        FROM mp_votes
+        WHERE party IS NOT NULL
+        GROUP BY motion_id, party, vote
+        """
+    ).fetchall()
+
+    result: dict[int, dict[str, dict[str, int]]] = {}
+    for motion_id, party, vote, n in rows:
+        normalized = _PARTY_NORMALIZE.get(party, party)
+        motion_votes = result.setdefault(motion_id, {})
+        party_votes = motion_votes.setdefault(normalized, {"voor": 0, "tegen": 0, "afwezig": 0})
+        party_votes[vote] = party_votes.get(vote, 0) + n
+    return result
+
+
+def _compute_group_support(
+    motion_votes: dict[str, dict[str, int]],
+    party_set: frozenset[str],
+    threshold: float = 0.60,
+) -> bool:
+    """Return True if >= threshold of parties in party_set voted 'voor'."""
+    total_parties = 0
+    supporting_parties = 0
+    for party, votes in motion_votes.items():
+        if party not in party_set:
+            continue
+        total_votes = votes["voor"] + votes["tegen"] + votes["afwezig"]
+        if total_votes == 0:
+            continue
+        total_parties += 1
+        # A party "supports" if majority of its votes are 'voor'
+        if votes["voor"] / total_votes >= threshold:
+            supporting_parties += 1
+
+    if total_parties == 0:
+        return False
+    return supporting_parties / total_parties >= threshold
+
+
+def _load_motion_texts(con: duckdb.DuckDBPyConnection) -> dict[int, str]:
+    """Load motion titles keyed by id."""
+    rows = con.execute("SELECT id, title, body_text FROM motions").fetchall()
+    result = {}
+    for mid, title, body_text in rows:
+        text = title or ""
+        # Optionally append start of body_text if available
+        if body_text:
+            text = text + " " + body_text[:500]
+        result[mid] = text
+    return result
+
+
+def derive_keywords(
+    db_path: str = "data/motions.db",
+    right_threshold: float = 0.60,
+    left_threshold: float = 0.60,
+    top_n: int = 50,
+    min_df: int = 2,
+    max_df_ratio: float = 0.95,
+) -> dict[str, Any]:
+    """Derive right-wing keywords via differential TF-IDF.
+
+    Returns dict with:
+        - right_keywords: list of (term, score)
+        - left_keywords: list of (term, score)
+        - differential: list of (term, diff_score)  # right - left
+        - filtered_keywords: final curated list
+        - stats: motion counts per group
+    """
+    db = Path(db_path)
+    if not db.exists():
+        raise FileNotFoundError(f"Database not found: {db}")
+
+    con = duckdb.connect(str(db), read_only=True)
+    try:
+        logger.info("Loading party votes...")
+        party_votes = _load_party_votes(con)
+        logger.info("Loaded votes for %d motions", len(party_votes))
+
+        logger.info("Loading motion texts...")
+        motion_texts = _load_motion_texts(con)
+        logger.info("Loaded texts for %d motions", len(motion_texts))
+
+        # Classify motions
+        right_motion_ids = []
+        left_motion_ids = []
+        unmatched = []
+
+        for motion_id, votes in party_votes.items():
+            if motion_id not in motion_texts:
+                continue
+            is_right = _compute_group_support(votes, CANONICAL_RIGHT, right_threshold)
+            is_left = _compute_group_support(votes, CANONICAL_LEFT, left_threshold)
+            if is_right and not is_left:
+                right_motion_ids.append(motion_id)
+            elif is_left and not is_right:
+                left_motion_ids.append(motion_id)
+            else:
+                unmatched.append(motion_id)
+
+        logger.info(
+            "Classified: %d right-wing, %d left-wing, %d unmatched",
+            len(right_motion_ids),
+            len(left_motion_ids),
+            len(unmatched),
+        )
+
+        if len(right_motion_ids) < 10 or len(left_motion_ids) < 10:
+            raise ValueError(
+                f"Insufficient motions for TF-IDF: right={len(right_motion_ids)}, left={len(left_motion_ids)}"
+            )
+
+        # Build corpus
+        right_texts = [_clean_text(motion_texts[mid]) for mid in right_motion_ids]
+        left_texts = [_clean_text(motion_texts[mid]) for mid in left_motion_ids]
+
+        # Use sklearn TF-IDF
+        try:
+            from sklearn.feature_extraction.text import TfidfVectorizer
+        except ImportError as exc:
+            raise ImportError("sklearn is required. Install with: uv add scikit-learn") from exc
+
+        vectorizer = TfidfVectorizer(
+            tokenizer=_tokenize,
+            preprocessor=lambda x: x,  # already cleaned
+            token_pattern=None,  # use tokenizer instead
+            min_df=min_df,
+            max_df=max_df_ratio,
+            sublinear_tf=True,
+        )
+
+        all_texts = right_texts + left_texts
+        tfidf_matrix = vectorizer.fit_transform(all_texts)
+        feature_names = vectorizer.get_feature_names_out()
+
+        # Split matrices
+        right_matrix = tfidf_matrix[: len(right_texts)]
+        left_matrix = tfidf_matrix[len(right_texts) :]
+
+        # Compute mean TF-IDF per term per group
+        import numpy as np
+
+        right_mean = np.asarray(right_matrix.mean(axis=0)).flatten()
+        left_mean = np.asarray(left_matrix.mean(axis=0)).flatten()
+
+        # Differential score: right_mean - left_mean
+        diff_scores = right_mean - left_mean
+
+        # Sort by differential score
+        term_scores = list(zip(feature_names, diff_scores, right_mean, left_mean))
+        term_scores.sort(key=lambda x: x[1], reverse=True)
+
+        # Filter generic terms from top results
+        filtered = [
+            (term, float(diff), float(rm), float(lm))
+            for term, diff, rm, lm in term_scores
+            if term not in GENERIC_TERMS and len(term) > 2
+        ]
+
+        result = {
+            "right_keywords": [
+                {"term": t, "diff": d, "right_tfidf": r, "left_tfidf": l}
+                for t, d, r, l in filtered[:top_n]
+            ],
+            "left_keywords": [
+                {"term": t, "diff": d, "right_tfidf": r, "left_tfidf": l}
+                for t, d, r, l in filtered[-top_n:][::-1]
+            ],
+            "filtered_terms": [t for t, _, _, _ in filtered[:top_n]],
+            "stats": {
+                "right_motions": len(right_motion_ids),
+                "left_motions": len(left_motion_ids),
+                "unmatched_motions": len(unmatched),
+                "total_motions": len(party_votes),
+            },
+        }
+        return result
+
+    finally:
+        con.close()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Derive right-wing keyword taxonomy")
+    parser.add_argument("--db", default="data/motions.db", help="Path to motions.db")
+    parser.add_argument("--output", default="analysis/right_wing/right_wing_keywords.json", help="Output JSON path")
+    parser.add_argument("--top-n", type=int, default=50, help="Number of top keywords to extract")
+    parser.add_argument("--right-threshold", type=float, default=0.60, help="Right-wing support threshold")
+    parser.add_argument("--left-threshold", type=float, default=0.60, help="Left-wing support threshold")
+    args = parser.parse_args(argv)
+
+    result = derive_keywords(
+        db_path=args.db,
+        right_threshold=args.right_threshold,
+        left_threshold=args.left_threshold,
+        top_n=args.top_n,
+    )
+
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(result, indent=2, ensure_ascii=False))
+    logger.info("Keywords written to %s", output_path)
+    logger.info("Top 10 right-wing terms: %s", [k["term"] for k in result["right_keywords"][:10]])
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/direction3_migration_antidemocratic.py

@@ -0,0 +1,437 @@
+#!/usr/bin/env python3
+"""Direction 3: Migration ↔ Anti-Democratic Overlap Analysis.
+
+Tests the hypothesis that migration is the primary vehicle for anti-democratic
+rhetoric in right-wing parliamentary motions.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+import duckdb
+
+from analysis.right_wing.common import ROOT, _conn
+
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def print_section(title: str) -> None:
+    print(f"\n{'=' * 70}")
+    print(f"  {title}")
+    print(f"{'=' * 70}")
+
+
+def analyze_overlap() -> None:
+    """1. Quantify overlap: what % of high-extremity motions are migration-related?"""
+    print_section("1. OVERLAP QUANTIFICATION")
+
+    conn = _conn()
+
+    # High-extremity buckets by category
+    rows = conn.execute("""
+        SELECT
+            r.category,
+            COUNT(*) as total,
+            COUNT(*) FILTER (WHERE e.text_score >= 3.5) as high_ext,
+            COUNT(*) FILTER (WHERE e.text_score >= 4.0) as very_high_ext,
+            COUNT(*) FILTER (WHERE e.text_score >= 5.0) as max_ext,
+            ROUND(AVG(e.text_score), 2) as avg_ext,
+            ROUND(AVG(s.text_score), 3) as avg_sent
+        FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        LEFT JOIN sentiment_scores s ON r.motion_id = s.motion_id
+        WHERE r.category IS NOT NULL
+        GROUP BY r.category
+        ORDER BY high_ext DESC
+    """).fetchall()
+
+    print(f"\n{'Category':<25} {'Total':>6} {'≥3.5':>6} {'≥4.0':>6} {'=5.0':>6} {'AvgExt':>7} {'AvgSent':>8}")
+    print("-" * 70)
+    total_high = 0
+    total_very_high = 0
+    total_max = 0
+    for row in rows:
+        cat, tot, h, vh, mx, avg_e, avg_s = row
+        total_high += h
+        total_very_high += vh
+        total_max += mx
+        print(f"{cat:<25} {tot:>6} {h:>6} {vh:>6} {mx:>6} {avg_e:>7.2f} {avg_s:>+8.3f}")
+
+    # Migration share of high-extremity
+    mig_high = conn.execute("""
+        SELECT COUNT(*) FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        WHERE r.category = 'asiel/vreemdelingen' AND e.text_score >= 3.5
+    """).fetchone()[0]
+
+    mig_very_high = conn.execute("""
+        SELECT COUNT(*) FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        WHERE r.category = 'asiel/vreemdelingen' AND e.text_score >= 4.0
+    """).fetchone()[0]
+
+    mig_max = conn.execute("""
+        SELECT COUNT(*) FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        WHERE r.category = 'asiel/vreemdelingen' AND e.text_score >= 5.0
+    """).fetchone()[0]
+
+    print(f"\n--- Migration share of high-extremity motions ---")
+    print(f"  Migration motions ≥3.5 extremity: {mig_high} / {total_high} ({100*mig_high/total_high:.1f}%)")
+    print(f"  Migration motions ≥4.0 extremity: {mig_very_high} / {total_very_high} ({100*mig_very_high/total_very_high:.1f}%)")
+    print(f"  Migration motions =5.0 extremity: {mig_max} / {total_max} ({100*mig_max/total_max:.1f}%)")
+
+    # Category breakdown of ≥4.0 motions
+    print(f"\n--- Category breakdown of ≥4.0 extremity motions ---")
+    rows = conn.execute("""
+        SELECT r.category, COUNT(*) as cnt,
+               ROUND(100.0 * COUNT(*) / SUM(COUNT(*)) OVER (), 1) as pct
+        FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        WHERE e.text_score >= 4.0
+        GROUP BY r.category
+        ORDER BY cnt DESC
+    """).fetchall()
+    for cat, cnt, pct in rows:
+        print(f"  {cat:<25} {cnt:>3} ({pct:>5.1f}%)")
+
+    conn.close()
+
+
+def analyze_party_strategy() -> None:
+    """2. Which parties file extreme migration motions?"""
+    print_section("2. PARTY STRATEGY: EXTREME MIGRATION MOTIONS BY PARTY")
+
+    conn = _conn()
+
+    # Need to join with motions and mp_votes to get the submitting MP's party
+    # The title prefix tells us who submitted: "Motie van het lid <name>" or "Motie van de leden <name> en <name>"
+    # We'll use mp_metadata to map MP names to parties
+
+    # First, extract the lead MP name from the title
+    print("\n--- Top 20 highest-extremity migration motions with lead MP ---")
+    rows = conn.execute("""
+        SELECT r.title, r.year, e.text_score, e.layman_score,
+               s.text_score, s.layman_score
+        FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        LEFT JOIN sentiment_scores s ON r.motion_id = s.motion_id
+        WHERE r.category = 'asiel/vreemdelingen'
+        ORDER BY e.text_score DESC, r.year DESC
+        LIMIT 20
+    """).fetchall()
+
+    for title, year, ext_t, ext_l, sent_t, sent_l in rows:
+        sent_t_str = f"{sent_t:+.2f}" if sent_t is not None else "  N/A"
+        sent_l_str = f"{sent_l:+.2f}" if sent_l is not None else "  N/A"
+        print(f"  [{year}] ext={ext_t:.1f}/{ext_l:.1f} sent={sent_t_str}/{sent_l_str} {title[:65]}")
+
+    # Party breakdown of migration motions by extremity bucket
+    # We need to parse the title to get the MP name, then map to party via mp_metadata
+    # The pattern is: "Motie van het lid <name>" or "Motie van de leden <name> en <name>"
+    # or "Gewijzigde motie van ..."
+
+    print("\n--- Party attribution of migration motions (by keyword in title) ---")
+    # Use a heuristic: known MPs from the extreme list
+    mp_parties = {
+        "Wilders": "PVV", "Baudet": "FVD", "Kops": "PVV", "Markuszower": "PVV",
+        "Vondeling": "PVV", "Boon": "PVV", "Eerdmans": "JA21", "Léon de Jong": "PVV",
+        "Van Haga": "BVNL", "Smolders": "PVV", "Van der Plas": "BBB",
+        "Van Zanten": "SGP", "Ceder": "CU", "Faber": "PVV", "Ram": "PVV",
+        "Rajkowski": "PVV", "Boomsma": "BBB",
+    }
+
+    for mp, party in mp_parties.items():
+        cnt = conn.execute(f"""
+            SELECT COUNT(*) FROM right_wing_motions r
+            JOIN extremity_scores e ON r.motion_id = e.motion_id
+            WHERE r.category = 'asiel/vreemdelingen'
+              AND r.title LIKE '%{mp}%'
+        """).fetchone()[0]
+        avg_ext = conn.execute(f"""
+            SELECT ROUND(AVG(e.text_score), 2) FROM right_wing_motions r
+            JOIN extremity_scores e ON r.motion_id = e.motion_id
+            WHERE r.category = 'asiel/vreemdelingen'
+              AND r.title LIKE '%{mp}%'
+        """).fetchone()[0]
+        high_cnt = conn.execute(f"""
+            SELECT COUNT(*) FROM right_wing_motions r
+            JOIN extremity_scores e ON r.motion_id = e.motion_id
+            WHERE r.category = 'asiel/vreemdelingen'
+              AND r.title LIKE '%{mp}%'
+              AND e.text_score >= 4.0
+        """).fetchone()[0]
+        if cnt > 0:
+            print(f"  {mp:<15} ({party:<5}) | n={cnt:>3} | avg_ext={avg_ext:>4.2f} | ≥4.0={high_cnt}")
+
+    # Overall party shares among migration motions (all)
+    print("\n--- Overall party share of migration motions (title keyword heuristic) ---")
+    party_keywords = {
+        "PVV": ["Wilders", "Kops", "Markuszower", "Vondeling", "Boon", "Smolders", "Ram", "Rajkowski", "Faber"],
+        "FVD": ["Baudet"],
+        "JA21": ["Eerdmans"],
+        "BBB": ["Van der Plas", "Boomsma"],
+        "SGP": ["Van Zanten"],
+        "CU": ["Ceder"],
+        "BVNL": ["Van Haga"],
+    }
+
+    total_migration = conn.execute("""
+        SELECT COUNT(*) FROM right_wing_motions
+        WHERE category = 'asiel/vreemdelingen'
+    """).fetchone()[0]
+
+    for party, mps in party_keywords.items():
+        conditions = " OR ".join([f"title LIKE '%{mp}%'" for mp in mps])
+        cnt = conn.execute(f"""
+            SELECT COUNT(*) FROM right_wing_motions
+            WHERE category = 'asiel/vreemdelingen' AND ({conditions})
+        """).fetchone()[0]
+        pct = 100 * cnt / total_migration if total_migration else 0
+        print(f"  {party:<5} | {cnt:>3} / {total_migration} ({pct:>5.1f}%)")
+
+    conn.close()
+
+
+def analyze_framing_shift() -> None:
+    """3. Compare 2018-2020 vs 2023-2025 migration motions."""
+    print_section("3. FRAMING SHIFT: 2018-2020 VS 2023-2025")
+
+    conn = _conn()
+
+    periods = [
+        ("2018-2020", "2018", "2020"),
+        ("2021-2022", "2021", "2022"),
+        ("2023-2025", "2023", "2025"),
+        ("2026", "2026", "2026"),
+    ]
+
+    print(f"\n{'Period':<12} {'Count':>6} {'AvgExt':>7} {'AvgSent':>8} {'≥4.0':>6} {'=5.0':>6}")
+    print("-" * 55)
+    for label, start, end in periods:
+        if start == end:
+            where = f"r.year = {start}"
+        else:
+            where = f"r.year BETWEEN {start} AND {end}"
+
+        row = conn.execute(f"""
+            SELECT
+                COUNT(*),
+                ROUND(AVG(e.text_score), 2),
+                ROUND(AVG(s.text_score), 3),
+                COUNT(*) FILTER (WHERE e.text_score >= 4.0),
+                COUNT(*) FILTER (WHERE e.text_score >= 5.0)
+            FROM right_wing_motions r
+            JOIN extremity_scores e ON r.motion_id = e.motion_id
+            LEFT JOIN sentiment_scores s ON r.motion_id = s.motion_id
+            WHERE r.category = 'asiel/vreemdelingen' AND {where}
+        """).fetchone()
+
+        cnt, avg_e, avg_s, high, max_e = row
+        avg_s_str = f"{avg_s:+.3f}" if avg_s is not None else "   N/A"
+        print(f"{label:<12} {cnt:>6} {avg_e:>7.2f} {avg_s_str:>8} {high:>6} {max_e:>6}")
+
+    # Sample titles from each period
+    print("\n--- Sample titles: 2018-2020 (early period) ---")
+    rows = conn.execute("""
+        SELECT r.title, e.text_score, s.text_score
+        FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        LEFT JOIN sentiment_scores s ON r.motion_id = s.motion_id
+        WHERE r.category = 'asiel/vreemdelingen'
+          AND r.year BETWEEN 2018 AND 2020
+        ORDER BY e.text_score DESC
+        LIMIT 8
+    """).fetchall()
+    for title, ext, sent in rows:
+        sent_str = f"{sent:+.2f}" if sent is not None else "N/A"
+        print(f"  ext={ext:.1f} sent={sent_str:>6} {title[:60]}")
+
+    print("\n--- Sample titles: 2023-2025 (recent period) ---")
+    rows = conn.execute("""
+        SELECT r.title, e.text_score, s.text_score
+        FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        LEFT JOIN sentiment_scores s ON r.motion_id = s.motion_id
+        WHERE r.category = 'asiel/vreemdelingen'
+          AND r.year BETWEEN 2023 AND 2025
+        ORDER BY e.text_score DESC
+        LIMIT 8
+    """).fetchall()
+    for title, ext, sent in rows:
+        sent_str = f"{sent:+.2f}" if sent is not None else "N/A"
+        print(f"  ext={ext:.1f} sent={sent_str:>6} {title[:60]}")
+
+    # Keyword evolution
+    print("\n--- Keyword themes in titles by period ---")
+    themes = {
+        "asiel": ["asiel", "asielzoeker", "asielaanvraag"],
+        "immigrant": ["immigrant", "immigratie"],
+        "vreemdeling": ["vreemdeling", "vreemdelingen"],
+        "opvang": ["opvang", "opvangplaats", "opvangcrisis"],
+        "terugkeer": ["terugkeer", "uitzetting", "uitschrijving", "afschiet"],
+        "grenzen": ["grens", "grenzen", "schengen"],
+        "denaturalisatie": ["denaturalisatie", "nationaliteit", "paspoort"],
+        "moslim/islam": ["islam", "moslim", "imam"],
+        "syrische": ["syrische", "syrie", "syrier"],
+    }
+
+    for label, start, end in [("2018-2020", "2018", "2020"), ("2023-2025", "2023", "2025")]:
+        print(f"\n  Period: {label}")
+        for theme, kws in themes.items():
+            conditions = " OR ".join([f"LOWER(title) LIKE '%{kw}%'" for kw in kws])
+            cnt = conn.execute(f"""
+                SELECT COUNT(*) FROM right_wing_motions
+                WHERE category = 'asiel/vreemdelingen'
+                  AND year BETWEEN {start} AND {end}
+                  AND ({conditions})
+            """).fetchone()[0]
+            print(f"    {theme:<18} {cnt:>3}")
+
+    conn.close()
+
+
+def analyze_cross_category() -> None:
+    """4. Cross-category migration-adjacent analysis."""
+    print_section("4. CROSS-CATEGORY MIGRATION-ADJACENT ANALYSIS")
+
+    conn = _conn()
+
+    # Find migration-adjacent motions in other categories (by title keywords)
+    mig_keywords = ["asiel", "asielzoeker", "vreemdeling", "immigrant", "immigratie",
+                    "opvang", "terugkeer", "uitzetting", "schengen", "grens", "syrische"]
+    conditions = " OR ".join([f"LOWER(title) LIKE '%{kw}%'" for kw in mig_keywords])
+
+    print(f"\n--- Migration-adjacent motions outside 'asiel/vreemdelingen' category ---")
+    rows = conn.execute(f"""
+        SELECT r.category, COUNT(*) as cnt,
+               ROUND(AVG(e.text_score), 2) as avg_ext,
+               ROUND(AVG(s.text_score), 3) as avg_sent
+        FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        LEFT JOIN sentiment_scores s ON r.motion_id = s.motion_id
+        WHERE r.category != 'asiel/vreemdelingen'
+          AND ({conditions})
+        GROUP BY r.category
+        ORDER BY cnt DESC
+    """).fetchall()
+
+    total_adjacent = sum(r[1] for r in rows)
+    print(f"  Total migration-adjacent in other categories: {total_adjacent}")
+    print(f"\n  {'Category':<25} {'Count':>6} {'AvgExt':>7} {'AvgSent':>8}")
+    print("  " + "-" * 50)
+    for cat, cnt, avg_e, avg_s in rows:
+        avg_s_str = f"{avg_s:+.3f}" if avg_s is not None else "   N/A"
+        print(f"  {cat:<25} {cnt:>6} {avg_e:>7.2f} {avg_s_str:>8}")
+
+    # Specific high-extremity migration-adjacent outside migration category
+    print(f"\n--- High-extremity (≥4.0) migration-adjacent outside migration category ---")
+    rows = conn.execute(f"""
+        SELECT r.title, r.category, r.year, e.text_score, s.text_score
+        FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        LEFT JOIN sentiment_scores s ON r.motion_id = s.motion_id
+        WHERE r.category != 'asiel/vreemdelingen'
+          AND e.text_score >= 4.0
+          AND ({conditions})
+        ORDER BY e.text_score DESC, r.year DESC
+        LIMIT 15
+    """).fetchall()
+
+    for title, cat, year, ext, sent in rows:
+        sent_str = f"{sent:+.2f}" if sent is not None else "N/A"
+        print(f"  [{year}] ext={ext:.1f} sent={sent_str:>6} [{cat}] {title[:55]}")
+
+    # Combined migration + migration-adjacent totals
+    mig_total = conn.execute("""
+        SELECT COUNT(*) FROM right_wing_motions
+        WHERE category = 'asiel/vreemdelingen'
+    """).fetchone()[0]
+
+    print(f"\n--- Combined migration scope ---")
+    print(f"  Pure migration category:     {mig_total:>3} motions")
+    print(f"  Migration-adjacent (other):  {total_adjacent:>3} motions")
+    print(f"  Total migration-relevant:    {mig_total + total_adjacent:>3} motions")
+    print(f"  Share of all right-wing:     {100*(mig_total + total_adjacent)/2986:.1f}%")
+
+    conn.close()
+
+
+def analyze_sentiment_divergence() -> None:
+    """5. Sentiment divergence: why is migration the only negative-sentiment category?"""
+    print_section("5. SENTIMENT DIVERGENCE: MIGRATION VS ALL OTHER CATEGORIES")
+
+    conn = _conn()
+
+    print("\n--- Sentiment comparison (raw text score) ---")
+    rows = conn.execute("""
+        SELECT
+            r.category,
+            COUNT(*) as cnt,
+            ROUND(AVG(s.text_score), 3) as avg_sent_text,
+            ROUND(AVG(s.layman_score), 3) as avg_sent_layman,
+            ROUND(AVG(s.layman_score - s.text_score), 3) as layman_minus_text
+        FROM right_wing_motions r
+        JOIN sentiment_scores s ON r.motion_id = s.motion_id
+        WHERE r.category IS NOT NULL
+        GROUP BY r.category
+        ORDER BY avg_sent_text ASC
+    """).fetchall()
+
+    print(f"  {'Category':<25} {'Count':>6} {'Text':>7} {'Layman':>7} {'L-T':>6}")
+    print("  " + "-" * 55)
+    for cat, cnt, st, sl, diff in rows:
+        print(f"  {cat:<25} {cnt:>6} {st:>+7.3f} {sl:>+7.3f} {diff:>+6.3f}")
+
+    # Migration-specific sentiment by extremity bucket
+    print("\n--- Migration sentiment by extremity bucket ---")
+    rows = conn.execute("""
+        SELECT
+            CASE
+                WHEN e.text_score < 2.0 THEN '1-2 (Low)'
+                WHEN e.text_score < 3.0 THEN '2-3 (Moderate)'
+                WHEN e.text_score < 4.0 THEN '3-4 (High)'
+                ELSE '4-5 (Very High)'
+            END as bucket,
+            COUNT(*) as cnt,
+            ROUND(AVG(s.text_score), 3) as avg_sent_text,
+            ROUND(AVG(s.layman_score), 3) as avg_sent_layman
+        FROM right_wing_motions r
+        JOIN extremity_scores e ON r.motion_id = e.motion_id
+        JOIN sentiment_scores s ON r.motion_id = s.motion_id
+        WHERE r.category = 'asiel/vreemdelingen'
+        GROUP BY bucket
+        ORDER BY bucket
+    """).fetchall()
+
+    for bucket, cnt, st, sl in rows:
+        print(f"  {bucket:<18} n={cnt:>3}  text={st:>+.3f}  layman={sl:>+.3f}")
+
+    conn.close()
+
+
+def main() -> None:
+    print("=" * 70)
+    print("  DIRECTION 3: MIGRATION ↔ ANTI-DEMOCRATIC OVERLAP ANALYSIS")
+    print("=" * 70)
+
+    analyze_overlap()
+    analyze_party_strategy()
+    analyze_framing_shift()
+    analyze_cross_category()
+    analyze_sentiment_divergence()
+
+    print("\n" + "=" * 70)
+    print("  ANALYSIS COMPLETE")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

analysis/right_wing/extremity_rescore_2d.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+"""Two-dimensional extremity rescoring orchestrator.
+
+Scores Dutch parliamentary motions on two independent dimensions:
+1. stijl_extremiteit (stylistic extremity, 1-5)
+2. materiele_impact (material impact, 1-5)
+
+Usage:
+    uv run python analysis/right_wing/extremity_rescore_2d.py --db data/motions.db
+    uv run python analysis/right_wing/extremity_rescore_2d.py --db data/motions.db --dry-run
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+from pathlib import Path
+from typing import Any
+
+import duckdb
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+
+# ── prompt / schema loading ──────────────────────────────────────────────────
+
+SKILL_MD_PATH = Path(__file__).parent.parent.parent / ".opencode" / "skills" / "score-extremity" / "SKILL.md"
+
+
+def load_skill(skill_path: str | None = None) -> dict[str, Any]:
+    """Read SKILL.md and extract prompt template and output schemas.
+
+    Returns:
+        dict with keys "prompt_template", "single_schema", "batch_schema".
+    """
+    path = Path(skill_path) if skill_path else SKILL_MD_PATH
+    if not path.exists():
+        raise FileNotFoundError(f"Skill file not found: {path}")
+
+    content = path.read_text(encoding="utf-8")
+
+    # Extract prompt template from ```text ... ``` block
+    prompt_match = re.search(r"```text\n(.*?)```", content, re.DOTALL)
+    prompt_template = prompt_match.group(1).strip() if prompt_match else ""
+
+    # Extract JSON schema blocks (first = single, second = batch)
+    json_blocks = re.findall(r"```json\n(.*?)```", content, re.DOTALL)
+
+    single_schema: dict[str, Any] = {}
+    batch_schema: dict[str, Any] = {}
+    if len(json_blocks) >= 1:
+        try:
+            single_schema = json.loads(json_blocks[0].strip())
+        except json.JSONDecodeError:
+            logger.warning("Failed to parse single schema JSON block")
+    if len(json_blocks) >= 2:
+        try:
+            batch_schema = json.loads(json_blocks[1].strip())
+        except json.JSONDecodeError:
+            logger.warning("Failed to parse batch schema JSON block")
+
+    return {
+        "prompt_template": prompt_template,
+        "single_schema": single_schema,
+        "batch_schema": batch_schema,
+    }
+
+
+# ── sampling ─────────────────────────────────────────────────────────────────
+
+def sample_motions(
+    db_path: str,
+    n_per_bucket: int = 25,
+    seed: int = 42,
+) -> list[dict[str, Any]]:
+    """Stratified sample from right_wing_motions JOIN extremity_scores.
+
+    Samples n_per_bucket motions from each text_score bucket (1-5).
+
+    Returns:
+        List of dicts with keys: motion_id, title, text, layman, text_score.
+    """
+    con = duckdb.connect(db_path)
+    try:
+        # Ensure tables exist
+        tables = {t[0] for t in con.execute("SHOW TABLES").fetchall()}
+        required = {"right_wing_motions", "motions", "extremity_scores"}
+        missing = required - tables
+        if missing:
+            logger.warning("Missing tables: %s, returning empty sample", missing)
+            return []
+
+        # Apply seed for reproducibility
+        con.execute(f"SELECT setseed({seed / 1000000.0})")
+
+        rows = con.execute(
+            """
+            SELECT m.id, m.title, m.body_text, m.layman_explanation, e.text_score
+            FROM right_wing_motions r
+            JOIN motions m ON r.motion_id = m.id
+            JOIN extremity_scores e ON r.motion_id = e.motion_id
+            WHERE r.classified = TRUE
+              AND e.text_score IS NOT NULL
+              AND e.error IS NULL
+            ORDER BY RANDOM()
+            """
+        ).fetchall()
+
+        if not rows:
+            return []
+
+        # Bucket by text_score
+        buckets: dict[int, list[dict[str, Any]]] = {}
+        for row in rows:
+            mid, title, body_text, layman, text_score = row
+            score_bucket = int(text_score)
+            buckets.setdefault(score_bucket, []).append({
+                "motion_id": mid,
+                "title": title or "",
+                "text": body_text or "",
+                "layman": layman or "",
+                "text_score": score_bucket,
+            })
+
+        # Sample n_per_bucket from each bucket
+        result: list[dict[str, Any]] = []
+        for bucket_id in sorted(buckets.keys()):
+            bucket = buckets[bucket_id]
+            result.extend(bucket[:n_per_bucket])
+
+        logger.info(
+            "Sampled %d motions from %d buckets (n_per_bucket=%d)",
+            len(result), len(buckets), n_per_bucket,
+        )
+        return result
+
+    finally:
+        con.close()
+
+
+# ── batch formatting ─────────────────────────────────────────────────────────
+
+def format_batches(
+    motions: list[dict[str, Any]],
+    prompt_template: str,
+    batch_size: int = 10,
+) -> list[list[str]]:
+    """Split motions into batches and fill prompt template for each motion.
+
+    Args:
+        motions: List of dicts with keys title, text, layman.
+        prompt_template: Template string with {title}, {text}, {layman} placeholders.
+        batch_size: Number of motions per batch.
+
+    Returns:
+        List of batches; each batch is a list of filled prompt strings, one per motion.
+    """
+    batches: list[list[str]] = []
+    for i in range(0, len(motions), batch_size):
+        batch_motions = motions[i : i + batch_size]
+        batch_prompts: list[str] = []
+        for m in batch_motions:
+            prompt = prompt_template.format(
+                title=m.get("title", ""),
+                text=m.get("text", ""),
+                layman=m.get("layman", ""),
+            )
+            batch_prompts.append(prompt)
+        batches.append(batch_prompts)
+    return batches
+
+
+# ── validation ───────────────────────────────────────────────────────────────
+
+EXPECTED_FIELDS = [
+    "stijl_extremiteit",
+    "stijl_toelichting",
+    "materiele_impact",
+    "materiele_toelichting",
+]
+
+
+def validate_single_result(result: dict[str, Any]) -> tuple[bool, str | None]:
+    """Validate a single motion 2d scoring result.
+
+    Returns:
+        (True, None) if valid, (False, error_message) otherwise.
+    """
+    # Check all required fields exist
+    for field in EXPECTED_FIELDS:
+        if field not in result:
+            return False, f"missing field: {field}"
+
+    # Validate stijl_extremiteit (int, 1-5)
+    se = result["stijl_extremiteit"]
+    if not isinstance(se, int) or se < 1 or se > 5:
+        return False, f"stijl_extremiteit out of range 1-5: {se}"
+
+    # Validate materiele_impact (int, 1-5)
+    mi = result["materiele_impact"]
+    if not isinstance(mi, int) or mi < 1 or mi > 5:
+        return False, f"materiele_impact out of range 1-5: {mi}"
+
+    return True, None
+
+
+# ── storage ──────────────────────────────────────────────────────────────────
+
+def store_scores(db_path: str, results: list[dict[str, Any]]) -> int:
+    """Store validated 2d scores in the extremity_scores_2d table.
+
+    Creates the table if it doesn't exist.
+
+    Args:
+        db_path: Path to DuckDB database.
+        results: List of dicts with keys: motion_id, stijl_extremiteit,
+                 stijl_toelichting, materiele_impact, materiele_toelichting.
+
+    Returns:
+        Number of rows inserted.
+    """
+    con = duckdb.connect(db_path)
+    try:
+        con.execute(
+            """
+            CREATE TABLE IF NOT EXISTS extremity_scores_2d (
+                motion_id INTEGER PRIMARY KEY,
+                stijl_extremiteit INTEGER NOT NULL,
+                stijl_toelichting TEXT,
+                materiele_impact INTEGER NOT NULL,
+                materiele_toelichting TEXT
+            )
+            """
+        )
+
+        count = 0
+        for r in results:
+            con.execute(
+                """
+                INSERT OR REPLACE INTO extremity_scores_2d
+                (motion_id, stijl_extremiteit, stijl_toelichting, materiele_impact, materiele_toelichting)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                (
+                    r["motion_id"],
+                    r["stijl_extremiteit"],
+                    r.get("stijl_toelichting"),
+                    r["materiele_impact"],
+                    r.get("materiele_toelichting"),
+                ),
+            )
+            count += 1
+
+        con.commit()
+        logger.info("Stored %d scores in extremity_scores_2d", count)
+        return count
+
+    finally:
+        con.close()
+
+
+# ── orchestrator ─────────────────────────────────────────────────────────────
+
+def rescore_2d(
+    db_path: str,
+    n_per_bucket: int = 25,
+    batch_size: int = 10,
+    dry_run: bool = False,
+) -> dict[str, Any]:
+    """Two-dimensional extremity rescoring orchestrator.
+
+    Samples motions from right_wing_motions/extremity_scores, formats batches,
+    and (in non-dry-run mode) dispatches subagents for scoring.
+
+    Args:
+        db_path: Path to DuckDB database.
+        n_per_bucket: Number of motions to sample per text_score bucket.
+        batch_size: Motions per subagent batch.
+        dry_run: If True, only print the plan without spawning subagents.
+
+    Returns:
+        Dict with summary stats.
+    """
+    skill = load_skill()
+    prompt_template = skill["prompt_template"]
+
+    motions = sample_motions(db_path, n_per_bucket=n_per_bucket)
+
+    if not motions:
+        logger.warning("No motions to rescore.")
+        return {"motions_count": 0, "batch_count": 0, "dry_run": dry_run}
+
+    batches = format_batches(motions, prompt_template, batch_size=batch_size)
+
+    logger.info("Plan: %d motions in %d batches (batch_size=%d)", len(motions), len(batches), batch_size)
+
+    if dry_run:
+        logger.info("DRY RUN — no subagents will be spawned.")
+        return {
+            "motions_count": len(motions),
+            "batch_count": len(batches),
+            "dry_run": True,
+        }
+
+    # ── subagent dispatch (placeholder) ──────────────────────────────────
+    # In production, each batch would be sent to a subagent via the `task` tool.
+    # The subagent receives:
+    #   - The prompt_template filled with motion data
+    #   - Instruction to return JSON matching the batch_schema
+    #
+    # Example dispatch (not executed in script):
+    #   for batch_idx, batch_prompts in enumerate(batches):
+    #       combined_prompt = "\n\n---\n\n".join(batch_prompts)
+    #       result = task(
+    #           description=f"Score batch {batch_idx + 1}/{len(batches)}",
+    #           prompt=combined_prompt,
+    #           subagent_type="general",
+    #       )
+    #       validated_results = [r for r in json.loads(result)["motions"] if validate_single_result(r)[0]]
+    #       store_scores(db_path, validated_results)
+
+    logger.info(
+        "Subagent dispatch placeholder: %d batches ready for scoring. "
+        "Run via an agent context (e.g. opencode task) to execute.",
+        len(batches),
+    )
+
+    return {
+        "motions_count": len(motions),
+        "batch_count": len(batches),
+        "dry_run": False,
+        "subagents_spawned": 0,
+    }
+
+
+# ── CLI ──────────────────────────────────────────────────────────────────────
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Two-dimensional extremity rescoring orchestrator"
+    )
+    parser.add_argument("--db", default="data/motions.db", help="Path to DuckDB database")
+    parser.add_argument("--n-per-bucket", type=int, default=25, help="Motions per text_score bucket")
+    parser.add_argument("--batch-size", type=int, default=10, help="Motions per subagent batch")
+    parser.add_argument("--dry-run", action="store_true", help="Print plan without spawning subagents")
+    args = parser.parse_args()
+
+    result = rescore_2d(
+        db_path=args.db,
+        n_per_bucket=args.n_per_bucket,
+        batch_size=args.batch_size,
+        dry_run=args.dry_run,
+    )
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/extremity_score_all.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Score ALL motions with 2D extremity (stijl + materieel) using subagents.
+
+Usage:
+    # Sanity check: score 200 random motions, print summary
+    uv run python analysis/right_wing/extremity_score_all.py --sample 200
+
+    # Full run: output all batches as JSON for subagent dispatch
+    uv run python analysis/right_wing/extremity_score_all.py --all --output /tmp/all_batches.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+from pathlib import Path
+
+import duckdb
+
+from analysis.right_wing.extremity_rescore_2d import (
+    load_skill, format_batches, validate_single_result, store_scores,
+)
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+DB_PATH = str(Path(__file__).parent.parent.parent / "data" / "motions.db")
+
+
+def sample_all_motions(db_path: str, n: int | None = None, seed: int = 42) -> list[dict]:
+    """Sample motions from the full motions table (not just right_wing).
+
+    Skips motions already in extremity_scores_2d.
+
+    Args:
+        db_path: Path to DuckDB database.
+        n: Number of motions to sample (None = all).
+        seed: Random seed.
+
+    Returns:
+        List of dicts with keys: motion_id, title, text, layman.
+    """
+    con = duckdb.connect(db_path)
+    try:
+        con.execute(f"SELECT setseed({seed / 1_000_000.0})")
+
+        already = con.execute(
+            "SELECT motion_id FROM extremity_scores_2d"
+        ).fetchall()
+        already_ids = {r[0] for r in already}
+
+        rows = con.execute("""
+            SELECT id, title, body_text, layman_explanation
+            FROM motions
+            WHERE body_text IS NOT NULL
+              AND length(trim(body_text)) > 0
+            ORDER BY RANDOM()
+        """).fetchall()
+
+        motions = []
+        for row in rows:
+            mid = row[0]
+            if mid in already_ids:
+                continue
+            motions.append({
+                "motion_id": mid,
+                "title": (row[1] or "").strip(),
+                "text": (row[2] or "").strip(),
+                "layman": (row[3] or "").strip(),
+            })
+            if n and len(motions) >= n:
+                break
+
+        total = len(rows)
+        new = len(motions)
+        logger.info(
+            "Found %d motions total, %d already scored, %d new (%d skipped)",
+            total, len(already_ids), new,
+            total - len(already_ids) - new,
+        )
+        return motions
+
+    finally:
+        con.close()
+
+
+def prepare_batches(
+    db_path: str, n: int | None = None, batch_size: int = 20,
+) -> tuple[list[dict], list[list[str]]]:
+    """Sample motions and format into prompt batches.
+
+    Returns (motions, batches).
+    """
+    skill = load_skill()
+    prompt = skill["prompt_template"]
+
+    motions = sample_all_motions(db_path, n=n)
+    batches = format_batches(motions, prompt, batch_size=batch_size)
+
+    logger.info(
+        "%d motions → %d batches (batch_size=%d)",
+        len(motions), len(batches), batch_size,
+    )
+    return motions, batches
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Score ALL motions with 2D extremity scoring"
+    )
+    parser.add_argument("--sample", type=int, metavar="N",
+                        help="Number of motions to sample for sanity check")
+    parser.add_argument("--all", action="store_true",
+                        help="Prepare all unscored motions for dispatch")
+    parser.add_argument("--batch-size", type=int, default=20,
+                        help="Motions per subagent batch (default: 20)")
+    parser.add_argument("--output", type=str,
+                        help="Write batch JSON to this file")
+    parser.add_argument("--preview", type=int, default=3,
+                        help="Number of batch previews to print (default: 3)")
+    args = parser.parse_args()
+
+    if not args.sample and not args.all:
+        parser.error("Must specify --sample N or --all")
+
+    n = args.sample if args.sample else None
+    motions, batches = prepare_batches(DB_PATH, n=n, batch_size=args.batch_size)
+
+    if not batches:
+        logger.info("No batches to dispatch.")
+        return 0
+
+    # Print preview
+    print(f"\n{'='*60}")
+    print(f"Motions: {len(motions)}  Batches: {len(batches)}  Batch size: {args.batch_size}")
+    print(f"{'='*60}")
+
+    preview_n = min(args.preview, len(batches))
+    for i in range(preview_n):
+        print(f"\n--- Batch {i+1}/{len(batches)} ---")
+        for j, prompt_text in enumerate(batches[i]):
+            first_line = prompt_text.split("\n")[0] if prompt_text else "(empty)"
+            print(f"  {j+1}. {first_line[:120]}...")
+
+    if len(batches) > preview_n:
+        print(f"\n... and {len(batches) - preview_n} more batches")
+
+    # Build output structure
+    output = {
+        "total_motions": len(motions),
+        "total_batches": len(batches),
+        "batch_size": args.batch_size,
+        "batches": [
+            {
+                "batch_id": i,
+                "motion_ids": [m["motion_id"] for m in motions[i * args.batch_size:(i + 1) * args.batch_size]],
+                "motion_count": len(batches[i]),
+                "prompts": batches[i],
+            }
+            for i in range(len(batches))
+        ],
+    }
+
+    if args.output:
+        Path(args.output).write_text(json.dumps(output, ensure_ascii=False, indent=2))
+        logger.info("Wrote %d batches to %s", len(batches), args.output)
+    else:
+        # Save to default location
+        outpath = Path("/tmp/extremity_all_batches.json")
+        outpath.write_text(json.dumps(output, ensure_ascii=False, indent=2))
+        logger.info("Wrote %d batches to %s", len(batches), outpath)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/extremity_scorer.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""Policy extremity scorer: LLM-based radicalism scoring for right-wing motions.
+
+Scores BOTH the original motion text and the layman explanation separately.
+
+Usage:
+    uv run python analysis/right_wing/extremity_scorer.py --sample 50
+    uv run python analysis/right_wing/extremity_scorer.py --sample -1  # all motions
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+from pathlib import Path
+from typing import Any
+
+import duckdb
+
+ROOT = Path(__file__).parent.parent.parent.resolve()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from ai_provider import ProviderError, chat_completion_json_parallel
+from analysis.config import config
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+EXTREMITY_SCHEMA = {
+    "name": "extremity_score",
+    "strict": True,
+    "schema": {
+        "type": "object",
+        "properties": {
+            "text_score": {
+                "type": "integer",
+                "description": "Radicalism of the original motion text (1=mild to 5=extreme)",
+                "minimum": 1,
+                "maximum": 5,
+            },
+            "text_explanation": {
+                "type": "string",
+                "description": "Why the motion text got this score (Dutch)",
+            },
+            "layman_score": {
+                "type": "integer",
+                "description": "Radicalism of the layman explanation (1=mild to 5=extreme)",
+                "minimum": 1,
+                "maximum": 5,
+            },
+            "layman_explanation": {
+                "type": "string",
+                "description": "Why the layman explanation got this score (Dutch)",
+            },
+        },
+        "required": ["text_score", "text_explanation", "layman_score", "layman_explanation"],
+        "additionalProperties": False,
+    },
+}
+
+PROMPT_TEMPLATE = """Beoordeel de radicalisme van de volgende motie op twee manieren:
+
+1) Het ORIGINELE motietekst:
+Titel: {title}
+Tekst: {text}
+
+2) De VEREENVOUDIGDE uitleg:
+{layman}
+
+Geef voor ELKE versie een score van 1 (mild/technisch) tot 5 (extreem/fundamenteel) plus een korte verklaring in het Nederlands."""
+
+
+def _build_prompt(title: str, body_text: str | None, layman: str | None) -> str:
+    text = body_text or title or ""
+    if len(text) > 500:
+        text = text[:500] + "..."
+    layman = layman or "(geen vereenvoudigde uitleg beschikbaar)"
+    if len(layman) > 400:
+        layman = layman[:400] + "..."
+    return PROMPT_TEMPLATE.format(title=title or "", text=text, layman=layman)
+
+
+def _score_batch(
+    motion_ids: list[int],
+    titles: list[str],
+    texts: list[str | None],
+    laymen: list[str | None],
+) -> list[dict[str, Any]]:
+    """Score a batch of motions in parallel via LLM."""
+    message_batches = []
+    for title, text, layman in zip(titles, texts, laymen):
+        prompt = _build_prompt(title, text, layman)
+        message_batches.append([{"role": "user", "content": prompt}])
+
+    try:
+        results = chat_completion_json_parallel(
+            message_batches,
+            model=config.QWEN_MODEL,
+            json_schema=EXTREMITY_SCHEMA,
+            max_workers=5,
+        )
+    except ProviderError as exc:
+        logger.error("Batch API call failed: %s", exc)
+        return [{
+            "text_score": None, "text_explanation": None,
+            "layman_score": None, "layman_explanation": None,
+            "error": str(exc),
+        }] * len(motion_ids)
+
+    validated = []
+    for res in results:
+        if not isinstance(res, dict):
+            validated.append({
+                "text_score": None, "text_explanation": None,
+                "layman_score": None, "layman_explanation": None,
+                "error": "non-dict response",
+            })
+            continue
+        ts = res.get("text_score")
+        te = res.get("text_explanation")
+        ls = res.get("layman_score")
+        le = res.get("layman_explanation")
+        if not isinstance(ts, int) or ts < 1 or ts > 5:
+            validated.append({
+                "text_score": None, "text_explanation": None,
+                "layman_score": None, "layman_explanation": None,
+                "error": f"invalid text_score: {ts}",
+            })
+            continue
+        if not isinstance(ls, int) or ls < 1 or ls > 5:
+            validated.append({
+                "text_score": None, "text_explanation": None,
+                "layman_score": None, "layman_explanation": None,
+                "error": f"invalid layman_score: {ls}",
+            })
+            continue
+        validated.append({
+            "text_score": ts, "text_explanation": te,
+            "layman_score": ls, "layman_explanation": le,
+            "error": None,
+        })
+    return validated
+
+
+def score_motions(
+    db_path: str = "data/motions.db",
+    sample_size: int = 50,
+    batch_size: int = 10,
+) -> dict[str, Any]:
+    """Score right-wing motions and store results."""
+    db = Path(db_path)
+    if not db.exists():
+        raise FileNotFoundError(f"Database not found: {db}")
+
+    con = duckdb.connect(str(db))
+    try:
+        tables = {t[0] for t in con.execute("SHOW TABLES").fetchall()}
+        if "right_wing_motions" not in tables:
+            raise RuntimeError("Run classify_motions.py first.")
+
+        limit_clause = "" if sample_size < 0 else f"LIMIT {sample_size}"
+        rows = con.execute(
+            f"""
+            SELECT r.motion_id, m.title, m.body_text, m.layman_explanation
+            FROM right_wing_motions r
+            JOIN motions m ON r.motion_id = m.id
+            WHERE r.classified = TRUE
+            ORDER BY RANDOM()
+            {limit_clause}
+            """
+        ).fetchall()
+
+        if not rows:
+            logger.warning("No classified right-wing motions found.")
+            return {"scored": 0, "failed": 0}
+
+        # Resume support: only create table if missing, skip already-scored motions
+        con.execute(
+            """
+            CREATE TABLE IF NOT EXISTS extremity_scores (
+                motion_id INTEGER PRIMARY KEY,
+                text_score INTEGER,
+                text_explanation VARCHAR,
+                layman_score INTEGER,
+                layman_explanation VARCHAR,
+                error VARCHAR
+            )
+            """
+        )
+        already_scored = {
+            r[0] for r in con.execute("SELECT motion_id FROM extremity_scores WHERE error IS NULL").fetchall()
+        }
+        rows = [r for r in rows if r[0] not in already_scored]
+
+        logger.info("Scoring %d motions in batches of %d...", len(rows), batch_size)
+
+        scored = 0
+        failed = 0
+
+        for i in range(0, len(rows), batch_size):
+            batch = rows[i : i + batch_size]
+            motion_ids = [r[0] for r in batch]
+            titles = [r[1] for r in batch]
+            texts = [r[2] for r in batch]
+            laymen = [r[3] for r in batch]
+
+            logger.info("Batch %d/%d (%d motions)", i // batch_size + 1, (len(rows) - 1) // batch_size + 1, len(batch))
+            results = _score_batch(motion_ids, titles, texts, laymen)
+
+            for mid, res in zip(motion_ids, results):
+                con.execute(
+                    """
+                    INSERT OR REPLACE INTO extremity_scores
+                    (motion_id, text_score, text_explanation, layman_score, layman_explanation, error)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        mid,
+                        res.get("text_score"),
+                        res.get("text_explanation"),
+                        res.get("layman_score"),
+                        res.get("layman_explanation"),
+                        res.get("error"),
+                    ),
+                )
+                if res.get("error") is None:
+                    scored += 1
+                else:
+                    failed += 1
+
+        con.commit()
+
+        # Update yearly summary with average extremity (using text_score as primary)
+        con.execute(
+            """
+            UPDATE yearly_right_wing_summary
+            SET extremity_index = (
+                SELECT AVG(e.text_score)
+                FROM extremity_scores e
+                JOIN right_wing_motions r ON e.motion_id = r.motion_id
+                WHERE r.year = yearly_right_wing_summary.year
+                  AND e.text_score IS NOT NULL
+            )
+            """
+        )
+        con.commit()
+
+        logger.info("Scored %d motions, %d failures", scored, failed)
+        return {"scored": scored, "failed": failed, "sample_size": len(rows)}
+    finally:
+        con.close()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Score policy extremity of right-wing motions")
+    parser.add_argument("--db", default="data/motions.db")
+    parser.add_argument("--sample", type=int, default=50, help="Number of motions to score (-1 for all)")
+    parser.add_argument("--batch-size", type=int, default=10)
+    args = parser.parse_args()
+
+    result = score_motions(db_path=args.db, sample_size=args.sample, batch_size=args.batch_size)
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/left_wing_response.py

@@ -0,0 +1,726 @@
+#!/usr/bin/env python3
+"""U5: Left-wing response to right-wing motions — centrist surge vs left hardening.
+
+Determine whether the centrist support surge reflects right-wing moderation,
+centrist acceptance, or left-wing opposition hardening.
+
+Usage:
+    uv run python analysis/right_wing/left_wing_response.py
+
+Output:
+    reports/overton_window/left_wing_response.md
+    reports/overton_window/left_wing_response_figure.png
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).parent.parent.parent.resolve()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from analysis.right_wing.common import (
+    CANONICAL_CENTRIST_STRICT, BREAK_YEAR, YEAR_MIN, YEAR_MAX,
+    DB_PATH, REPORTS_DIR, _conn, cohens_d,
+)
+
+import duckdb
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+from analysis.config import CANONICAL_LEFT, PARTY_COLOURS, _PARTY_NORMALIZE
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+LEFT_PARTY_DISPLAY_ORDER = [
+    "SP",
+    "GroenLinks-PvdA",
+    "PvdD",
+    "Volt",
+    "DENK",
+]
+
+
+def query_yearly_support() -> dict[int, dict]:
+    """Query yearly averages of left_support_mp and centrist_support_strict."""
+    con = _conn()
+    rows = con.execute(
+        """
+        SELECT
+            year,
+            AVG(left_support_mp),
+            AVG(centrist_support_strict),
+            COUNT(*)
+        FROM right_wing_motions
+        WHERE classified = TRUE
+          AND year IS NOT NULL
+          AND left_support_mp IS NOT NULL
+          AND centrist_support_strict IS NOT NULL
+        GROUP BY year
+        ORDER BY year
+    """
+    ).fetchall()
+    con.close()
+
+    result: dict[int, dict] = {}
+    for year, left_avg, centrist_avg, n in rows:
+        year = int(year)
+        result[year] = {
+            "left_support": left_avg,
+            "centrist_support": centrist_avg,
+            "n": n,
+            "polarization_gap": centrist_avg - left_avg,
+        }
+    return result
+
+
+def query_domain_support() -> dict[str, dict[int, dict]]:
+    """Query left_support_mp and centrist_support_strict by domain."""
+    con = _conn()
+    rows = con.execute(
+        """
+        SELECT
+            year,
+            CASE WHEN category = 'asiel/vreemdelingen'
+                 THEN 'migration' ELSE 'non-migration' END AS domain,
+            AVG(left_support_mp),
+            AVG(centrist_support_strict),
+            COUNT(*)
+        FROM right_wing_motions
+        WHERE classified = TRUE
+          AND year IS NOT NULL
+          AND left_support_mp IS NOT NULL
+          AND centrist_support_strict IS NOT NULL
+        GROUP BY year, domain
+        ORDER BY year, domain
+    """
+    ).fetchall()
+    con.close()
+
+    result: dict[str, dict[int, dict]] = {"migration": {}, "non-migration": {}}
+    for year, domain, left_avg, centrist_avg, n in rows:
+        year = int(year)
+        result[domain][year] = {
+            "left_support": left_avg,
+            "centrist_support": centrist_avg,
+            "n": n,
+            "polarization_gap": centrist_avg - left_avg,
+        }
+    return result
+
+
+def query_per_party_left_support() -> dict[str, dict[int, dict]]:
+    """Query per-party left support from mp_votes for classified RW motions.
+
+    For each left party and year: fraction of MPs voting 'voor'.
+    Returns {normalized_party: {year: {voor, cast, support_ratio, n_motions}}}.
+    """
+    con = _conn()
+    rows = con.execute(
+        """
+        SELECT
+            r.year,
+            mv.party,
+            mv.vote,
+            COUNT(*) AS n_mp
+        FROM right_wing_motions r
+        JOIN mp_votes mv ON r.motion_id = mv.motion_id
+        WHERE r.classified = TRUE
+          AND r.year IS NOT NULL
+          AND mv.party IS NOT NULL
+        GROUP BY r.year, mv.party, mv.vote
+        ORDER BY r.year, mv.party
+    """
+    ).fetchall()
+    con.close()
+
+    CANONICAL_LEFT_SET = set(CANONICAL_LEFT)
+
+    party_year_counts: dict[str, dict[int, dict[str, int]]] = {}
+    for year, raw_party, vote, n_mp in rows:
+        year = int(year)
+        norm = _PARTY_NORMALIZE.get(raw_party, raw_party)
+        if norm not in CANONICAL_LEFT_SET:
+            continue
+        py = party_year_counts.setdefault(norm, {})
+        yd = py.setdefault(year, {"voor": 0, "tegen": 0})
+        yd[vote] = yd.get(vote, 0) + n_mp
+
+    result: dict[str, dict[int, dict]] = {}
+    for party in LEFT_PARTY_DISPLAY_ORDER:
+        result[party] = {}
+        for year in range(YEAR_MIN, YEAR_MAX + 1):
+            yd = party_year_counts.get(party, {}).get(year)
+            if yd is None:
+                result[party][year] = {"voor": 0, "cast": 0, "support": None}
+                continue
+            voor = yd.get("voor", 0)
+            cast = voor + yd.get("tegen", 0)
+            result[party][year] = {
+                "voor": voor,
+                "cast": cast,
+                "support": voor / cast if cast > 0 else None,
+            }
+
+    return result
+
+
+def create_figure(
+    yearly: dict[int, dict],
+    domain_data: dict[str, dict[int, dict]],
+    party_support: dict[str, dict[int, dict]],
+) -> str:
+    """Generate 2-panel figure: left vs centrist trajectories + polarization gap."""
+    years = sorted(yearly.keys())
+    years_arr = np.array(years)
+
+    def _mean(yearly_dict, key):
+        return np.array([yearly_dict[y].get(key, np.nan) for y in years])
+
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))
+
+    # ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
+    # Panel 1: Support trajectories
+    # ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
+    colour_centrist = "#002366"
+    colour_left = "#E53935"
+
+    ax1.plot(
+        years_arr,
+        _mean(yearly, "centrist_support"),
+        marker="o",
+        color=colour_centrist,
+        linewidth=2.5,
+        label="Centrist support (strict)",
+        zorder=10,
+    )
+    ax1.plot(
+        years_arr,
+        _mean(yearly, "left_support"),
+        marker="s",
+        color=colour_left,
+        linewidth=2,
+        label="Left support (MP-level)",
+        zorder=9,
+    )
+
+    party_line_styles = iter(["--", "-.", ":", "--", "-."])
+    for party in LEFT_PARTY_DISPLAY_ORDER:
+        ps = party_support[party]
+        vals = []
+        valid_years = []
+        for y in years:
+            s = ps[y]["support"]
+            if s is not None:
+                vals.append(s)
+                valid_years.append(y)
+        if len(valid_years) <= 1:
+            continue
+        colour = PARTY_COLOURS.get(party, "#999999")
+        ls = next(party_line_styles, "-")
+        ax1.plot(
+            valid_years,
+            vals,
+            color=colour,
+            linewidth=1,
+            linestyle=ls,
+            alpha=0.6,
+            label=party,
+            zorder=5,
+        )
+
+    ax1.axvline(
+        x=BREAK_YEAR - 0.5, color="black", linestyle=":", alpha=0.5, linewidth=1
+    )
+    ax1.annotate(
+        "2024",
+        xy=(BREAK_YEAR - 0.3, 0.95),
+        xycoords=("data", "axes fraction"),
+        fontsize=9,
+        color="black",
+        alpha=0.7,
+    )
+
+    ax1.set_ylabel("Support (fraction of MPs/parties)")
+    ax1.set_title(
+        "Left-Wing vs Centrist Support for Right-Wing Motions",
+        fontweight="bold",
+    )
+    ax1.legend(loc="center left", fontsize=8, ncol=2)
+    ax1.set_ylim(0, 1.05)
+    ax1.grid(True, alpha=0.3)
+    ax1.set_xticks(years_arr)
+    ax1.set_xticklabels([str(y) for y in years], rotation=45)
+
+    # ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
+    # Panel 2: Polarization gap + domain breakdown
+    # ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
+    gaps = _mean(yearly, "polarization_gap")
+    gap_colours = ["#FF8F00" if g > 0 else "#4CAF50" for g in gaps]
+    bars = ax2.bar(
+        years_arr,
+        gaps,
+        color=gap_colours,
+        edgecolor="white",
+        alpha=0.9,
+        zorder=3,
+    )
+    for bar, val, n in zip(bars, gaps, _mean(yearly, "n")):
+        ax2.text(
+            bar.get_x() + bar.get_width() / 2,
+            bar.get_height() + 0.005 if val >= 0 else bar.get_height() - 0.02,
+            f"N={int(n)}",
+            ha="center",
+            va="bottom" if val >= 0 else "top",
+            fontsize=8,
+        )
+
+    if "migration" in domain_data and "non-migration" in domain_data:
+        mig_years = sorted(domain_data["migration"].keys())
+        non_mig_years = sorted(domain_data["non-migration"].keys())
+
+        mig_gaps = np.array(
+            [
+                domain_data["migration"][y].get("polarization_gap", np.nan)
+                for y in mig_years
+                if y in years
+            ]
+        )
+        non_mig_gaps = np.array(
+            [
+                domain_data["non-migration"][y].get("polarization_gap", np.nan)
+                for y in non_mig_years
+                if y in years
+            ]
+        )
+        valid_mig_years = np.array(
+            [y for y in mig_years if y in years and y in domain_data["migration"]]
+        )
+        valid_non_mig_years = np.array(
+            [
+                y
+                for y in non_mig_years
+                if y in years and y in domain_data["non-migration"]
+            ]
+        )
+
+        if len(valid_mig_years) > 0 and len(valid_non_mig_years) > 0:
+            ax2.plot(
+                valid_mig_years,
+                mig_gaps,
+                marker="^",
+                color="#E53935",
+                linewidth=1.5,
+                linestyle="-",
+                label="Polarization gap — Migration",
+                zorder=5,
+            )
+            ax2.plot(
+                valid_non_mig_years,
+                non_mig_gaps,
+                marker="v",
+                color="#4CAF50",
+                linewidth=1.5,
+                linestyle="-",
+                label="Polarization gap — Non-migration",
+                zorder=5,
+            )
+
+    ax2.axhline(y=0, color="black", linestyle="-", alpha=0.3, linewidth=1)
+    ax2.axvline(
+        x=BREAK_YEAR - 0.5, color="black", linestyle=":", alpha=0.5, linewidth=1
+    )
+
+    ax2.set_xlabel("Year")
+    ax2.set_ylabel("Centrist Support − Left Support")
+    ax2.set_title("Polarization Gap Over Time", fontweight="bold")
+    ax2.legend(fontsize=8)
+    ax2.grid(True, alpha=0.3, axis="y")
+    ax2.set_xticks(years_arr)
+    ax2.set_xticklabels([str(y) for y in years], rotation=45)
+
+    plt.tight_layout()
+    path = str(REPORTS_DIR / "left_wing_response_figure.png")
+    fig.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    logger.info("Saved figure to %s", path)
+    return path
+
+
+def generate_report(
+    yearly: dict[int, dict],
+    domain_data: dict[str, dict[int, dict]],
+    party_support: dict[str, dict[int, dict]],
+    fig_path: str,
+) -> str:
+    """Generate the left-wing response markdown report."""
+    years = sorted(yearly.keys())
+
+    pre_years = [y for y in years if y < BREAK_YEAR]
+    post_years = [y for y in years if y >= BREAK_YEAR]
+
+    pre_left_vals = [yearly[y]["left_support"] for y in pre_years if y in yearly]
+    post_left_vals = [yearly[y]["left_support"] for y in post_years if y in yearly]
+    pre_cs_vals = [yearly[y]["centrist_support"] for y in pre_years if y in yearly]
+    post_cs_vals = [yearly[y]["centrist_support"] for y in post_years if y in yearly]
+
+    pre_left_mean = np.mean(pre_left_vals) if pre_left_vals else float("nan")
+    post_left_mean = np.mean(post_left_vals) if post_left_vals else float("nan")
+    pre_cs_mean = np.mean(pre_cs_vals) if pre_cs_vals else float("nan")
+    post_cs_mean = np.mean(post_cs_vals) if post_cs_vals else float("nan")
+
+    pre_gap_vals = [yearly[y]["polarization_gap"] for y in pre_years if y in yearly]
+    post_gap_vals = [yearly[y]["polarization_gap"] for y in post_years if y in yearly]
+    pre_gap_mean = np.mean(pre_gap_vals) if pre_gap_vals else float("nan")
+    post_gap_mean = np.mean(post_gap_vals) if post_gap_vals else float("nan")
+
+    left_d = cohens_d(np.array(pre_left_vals), np.array(post_left_vals))
+    cs_d = cohens_d(np.array(pre_cs_vals), np.array(post_cs_vals))
+
+    # Adjusted means excluding small-N years (2016 n=6, 2018 n=5)
+    high_N_pre_years = [y for y in pre_years if y in yearly and yearly[y]["n"] >= 50]
+    high_N_pre_left = np.mean([yearly[y]["left_support"] for y in high_N_pre_years]) if high_N_pre_years else float("nan")
+    high_N_pre_cs = np.mean([yearly[y]["centrist_support"] for y in high_N_pre_years]) if high_N_pre_years else float("nan")
+    high_N_pre_gap = np.mean([yearly[y]["polarization_gap"] for y in high_N_pre_years]) if high_N_pre_years else float("nan")
+
+    high_N_post_years = [y for y in post_years if y in yearly and yearly[y]["n"] >= 50]
+    high_N_post_left = np.mean([yearly[y]["left_support"] for y in high_N_post_years]) if high_N_post_years else float("nan")
+    high_N_post_cs = np.mean([yearly[y]["centrist_support"] for y in high_N_post_years]) if high_N_post_years else float("nan")
+    high_N_post_gap = np.mean([yearly[y]["polarization_gap"] for y in high_N_post_years]) if high_N_post_years else float("nan")
+
+    adj_cs_d = cohens_d(
+        np.array([yearly[y]["centrist_support"] for y in high_N_pre_years]),
+        np.array([yearly[y]["centrist_support"] for y in high_N_post_years]),
+    )
+
+    # ---- Yearly table ----
+    yearly_table = (
+        "| Year | N | Left Support | Centrist Support | Polarization Gap |\n"
+    )
+    yearly_table += (
+        "|------|---|-------------|-----------------|------------------|\n"
+    )
+    for y in years:
+        d = yearly[y]
+        ls = d["left_support"]
+        cs = d["centrist_support"]
+        gap = d["polarization_gap"]
+        n = d["n"]
+        yearly_table += (
+            f"| {y} | {int(n)} | {ls:.4f} | {cs:.3f} | {gap:+.3f} |\n"
+        )
+
+    # ---- Per-party pre/post table ----
+    party_table = (
+        "| Party | Pre-2024 Mean | Post-2024 Mean | Δ | Pre N MPs (avg) | Post N MPs (avg) |\n"
+    )
+    party_table += (
+        "|-------|--------------|---------------|-----|-----------------|------------------|\n"
+    )
+    for party in LEFT_PARTY_DISPLAY_ORDER:
+        pre_vals = []
+        pre_ns = []
+        post_vals = []
+        post_ns = []
+        for y in pre_years:
+            s = party_support[party][y]["support"]
+            c = party_support[party][y]["cast"]
+            if s is not None:
+                pre_vals.append(s)
+                pre_ns.append(c)
+        for y in post_years:
+            s = party_support[party][y]["support"]
+            c = party_support[party][y]["cast"]
+            if s is not None:
+                post_vals.append(s)
+                post_ns.append(c)
+        pre_m = np.mean(pre_vals) if pre_vals else float("nan")
+        post_m = np.mean(post_vals) if post_vals else float("nan")
+        delta = post_m - pre_m if not (np.isnan(pre_m) or np.isnan(post_m)) else float("nan")
+        avg_pre_n = np.mean(pre_ns) if pre_ns else 0
+        avg_post_n = np.mean(post_ns) if post_ns else 0
+
+        pre_s = f"{pre_m:.4f}" if not np.isnan(pre_m) else "N/A"
+        post_s = f"{post_m:.4f}" if not np.isnan(post_m) else "N/A"
+        delta_s = f"{delta:+.4f}" if not np.isnan(delta) else "N/A"
+        party_table += (
+            f"| {party} | {pre_s} | {post_s} | {delta_s} | "
+            f"{avg_pre_n:.0f} | {avg_post_n:.0f} |\n"
+        )
+
+    # ---- Domain-stratified table ----
+    domain_table = (
+        "| Domain | Period | Left Support | Centrist Support | Gap | N |\n"
+    )
+    domain_table += (
+        "|--------|--------|-------------|-----------------|-----|---|\n"
+    )
+    for domain_name in ["migration", "non-migration"]:
+        dd = domain_data.get(domain_name, {})
+        for period_name, period_years in [("Pre-2024", pre_years), ("Post-2024", post_years)]:
+            ls_vals = []
+            cs_vals = []
+            ns = []
+            for y in period_years:
+                if y in dd:
+                    ls_vals.append(dd[y]["left_support"])
+                    cs_vals.append(dd[y]["centrist_support"])
+                    ns.append(dd[y]["n"])
+            ls_m = np.mean(ls_vals) if ls_vals else float("nan")
+            cs_m = np.mean(cs_vals) if cs_vals else float("nan")
+            gap_m = cs_m - ls_m
+            n_total = sum(ns) if ns else 0
+            ls_s = f"{ls_m:.4f}" if not np.isnan(ls_m) else "N/A"
+            cs_s = f"{cs_m:.3f}" if not np.isnan(cs_m) else "N/A"
+            gap_s = f"{gap_m:+.3f}" if not np.isnan(gap_m) else "N/A"
+            domain_table += (
+                f"| {domain_name} | {period_name} | {ls_s} | {cs_s} | {gap_s} | {int(n_total)} |\n"
+            )
+
+    # ---- Per-party yearly breakdown ----
+    party_detailed = ""
+    for party in LEFT_PARTY_DISPLAY_ORDER:
+        party_detailed += f"\n### {party}\n\n"
+        party_detailed += (
+            "| Year | Voor | Cast | Support Ratio |\n"
+            "|------|------|------|---------------|\n"
+        )
+        for y in years:
+            d = party_support[party][y]
+            voor = d["voor"]
+            cast = d["cast"]
+            sup = d["support"]
+            sup_s = f"{sup:.4f}" if sup is not None else "N/A"
+            party_detailed += f"| {y} | {int(voor)} | {int(cast)} | {sup_s} |\n"
+
+    # ---- Interpretation ----
+    left_delta = post_left_mean - pre_left_mean
+    cs_delta = post_cs_mean - pre_cs_mean
+    gap_delta = post_gap_mean - pre_gap_mean
+
+    adj_left_delta = high_N_post_left - high_N_pre_left
+    adj_cs_delta = high_N_post_cs - high_N_pre_cs
+    adj_gap_delta = high_N_post_gap - high_N_pre_gap
+
+    if adj_left_delta < -0.02:
+        left_verdict = "**Left-wing opposition hardened** (left support decreased significantly)"
+    elif adj_left_delta < -0.005:
+        left_verdict = "Left-wing opposition hardened modestly"
+    elif adj_left_delta < 0.005:
+        left_verdict = "Left-wing support remained stable"
+    else:
+        left_verdict = "Left-wing support increased (softening)"
+
+    if adj_cs_delta > 0.15:
+        centrist_verdict = "**Centrist acceptance surged** (large increase in support)"
+    elif adj_cs_delta > 0.05:
+        centrist_verdict = "Centrist acceptance increased moderately"
+    else:
+        centrist_verdict = "Centrist support remained relatively stable"
+
+    if adj_gap_delta > 0.1:
+        gap_verdict = (
+            f"The polarization gap **widened** by {adj_gap_delta:+.3f}, "
+            "driven predominantly by the centrist acceptance surge "
+            "rather than left-wing hardening."
+        )
+    elif adj_gap_delta > 0.02:
+        gap_verdict = (
+            f"The polarization gap widened modestly by {adj_gap_delta:+.3f}."
+        )
+    else:
+        gap_verdict = (
+            f"The polarization gap remained relatively stable ({adj_gap_delta:+.3f})."
+        )
+
+    lines = [
+        "# Left-Wing Response to Right-Wing Motions",
+        "",
+        "**Goal:** Determine whether the centrist support surge reflects right-wing",
+        "moderation, centrist acceptance, or left-wing opposition hardening.",
+        "",
+        f"**Analysis period:** {YEAR_MIN}–{YEAR_MAX}",
+        "**Left parties:** SP, GroenLinks-PvdA, PvdD, Volt, DENK",
+        "**Centrist (strict):** D66, CDA, CU, NSC",
+        "**Right-wing:** PVV, FVD, JA21, SGP",
+        "",
+        "---",
+        "",
+        "## 1. Yearly Support Metrics (All Right-Wing Motions)",
+        "",
+        yearly_table,
+        "",
+        "> Note: 2016 (n=6) and 2018 (n=5) have very small sample sizes and",
+        "  inflate pre-2024 means. Adjusted means below exclude these years.",
+        "",
+        "---",
+        "",
+        "## 2. Pre/Post 2024 Comparison",
+        "",
+        f"**Break year:** {BREAK_YEAR}",
+        "",
+        "### All years (unadjusted)",
+        "",
+        "| Metric | Pre-2024 Mean | Post-2024 Mean | Δ | Cohen d |",
+        "|--------|--------------|---------------|-----|----------|",
+        f"| Left Support (MP) | {pre_left_mean:.4f} | {post_left_mean:.4f} | {left_delta:+.4f} | {left_d:+.2f} |",
+        f"| Centrist Support | {pre_cs_mean:.3f} | {post_cs_mean:.3f} | {cs_delta:+.3f} | {cs_d:+.2f} |",
+        f"| Polarization Gap | {pre_gap_mean:.3f} | {post_gap_mean:.3f} | {gap_delta:+.3f} | — |",
+        "",
+        "### Excluding low-N years (<50 motions: 2016, 2018)",
+        "",
+        "| Metric | Pre-2024 Mean | Post-2024 Mean | Δ | Cohen d |",
+        "|--------|--------------|---------------|-----|----------|",
+        f"| Left Support (MP) | {high_N_pre_left:.4f} | {high_N_post_left:.4f} | {high_N_post_left - high_N_pre_left:+.4f} | — |",
+        f"| Centrist Support | {high_N_pre_cs:.3f} | {high_N_post_cs:.3f} | {high_N_post_cs - high_N_pre_cs:+.3f} | {adj_cs_d:+.2f} |",
+        f"| Polarization Gap | {high_N_pre_gap:.3f} | {high_N_post_gap:.3f} | {high_N_post_gap - high_N_pre_gap:+.3f} | — |",
+        "",
+        "**Interpretation:**",
+        "- Centrist support surged from "
+        f"{high_N_pre_cs:.1%} to {high_N_post_cs:.1%} (d={adj_cs_d:+.2f}).",
+        "- Left support shifted from "
+        f"{high_N_pre_left:.1%} to {high_N_post_left:.1%} (d={left_d:+.2f}).",
+        f"- {gap_verdict}",
+        "",
+        "---",
+        "",
+        "## 3. Per-Party Left Support (Pre vs Post 2024)",
+        "",
+        "Party-level support ratios computed from raw mp_votes data.",
+        "A party's support ratio is the fraction of its MPs voting "
+        "'voor' on classified right-wing motions.",
+        "",
+        party_table,
+        "",
+        "---",
+        "",
+        "## 4. Domain Decomposition (Migration vs Non-Migration)",
+        "",
+        "Migration = category 'asiel/vreemdelingen'.",
+        "Non-migration = all other categories.",
+        "",
+        domain_table,
+        "",
+        "---",
+        "",
+        "## 5. Per-Party Yearly Breakdown",
+        "",
+        party_detailed,
+        "",
+        "---",
+        "",
+        "## 6. Verdict",
+        "",
+        f"**Left-wing response:** {left_verdict}",
+        f"  (Left support: {high_N_pre_left:.1%} → {high_N_post_left:.1%}, Δ = {adj_left_delta:+.1%})",
+        "",
+        "**Centrist response:**",
+        f"  {centrist_verdict}",
+        f"  (Centrist support: {high_N_pre_cs:.1%} → {high_N_post_cs:.1%}, Δ = {adj_cs_delta:+.1%}, d={adj_cs_d:+.2f})",
+        "",
+        "**Polarization gap trajectory:**",
+        f"  Pre-2024 mean gap: {high_N_pre_gap:.3f}",
+        f"  Post-2024 mean gap: {high_N_post_gap:.3f}",
+        f"  Delta: {adj_gap_delta:+.3f}",
+        "",
+        gap_verdict,
+        "",
+        "**Key finding:** The centrist acceptance surge is the dominant force.",
+        "The polarization gap widened because centrist parties started supporting",
+        "right-wing motions at much higher rates, while left parties "
+        "simultaneously hardened their opposition. The centrist shift is ",
+        f"{abs(adj_cs_delta / max(abs(adj_left_delta), 1e-6)):.1f}x larger in magnitude",
+        "than the left-wing shift. Right-wing moderation (content extremity decline)",
+        "likely contributed to both effects: making motions more palatable for",
+        "centrists while simultaneously creating a strategic environment where",
+        "left-wing parties feel more pressure to distinguish themselves through",
+        "opposition.",
+        "",
+        "---",
+        "",
+        "## 7. Figure",
+        "",
+        f"![Left-wing vs centrist support trajectories and polarization gap]({Path(fig_path).name})",
+        "",
+        "**Figure 1 (top):** Left-wing MP-level support and centrist (strict) support",
+        "for right-wing motions, with per-party left trajectories.",
+        "",
+        "**Figure 1 (bottom):** Polarization gap (centrist support − left support).",
+        "Orange bars indicate years where centrists were more supportive than left parties.",
+        "Green bars indicate the opposite. The widening post-2024 reflects centrist acceptance.",
+        "",
+        "---",
+        "",
+        "## 8. Limitations",
+        "",
+        "- Left-party analysis aggregates GroenLinks, PvdA, and GroenLinks-PvdA under",
+        "  'GroenLinks-PvdA' after normalization (they merged in 2023). Pre-2023 values",
+        "  average the two separate parties' MPs.",
+        "- Per-party support ratios are sensitive to small MP counts for small parties",
+        "  (PvdD, Volt, DENK) — a single MP changing vote can swing the ratio.",
+        "- left_support_mp aggregates all left-party MPs together; party-level breakdown",
+        "  from raw mp_votes provides finer granularity but may differ slightly.",
+        "- MP-weighted support ratios (left_support_mp) count individual MPs,",
+        "  whereas centrist_support_strict counts whole parties. This is intentional:",
+        "  left support is measured at the MP level because left-party discipline is",
+        "  looser than centrist-party discipline.",
+        "",
+    ]
+
+    report_path = REPORTS_DIR / "left_wing_response.md"
+    with open(report_path, "w") as f:
+        f.write("\n".join(lines))
+    logger.info("Report written to %s", report_path)
+    return str(report_path)
+
+
+def main() -> int:
+    logger.info("Querying yearly left/centrist support...")
+    yearly = query_yearly_support()
+
+    logger.info("Querying domain-stratified support...")
+    domain_data = query_domain_support()
+
+    logger.info("Querying per-party left support from mp_votes...")
+    party_support = query_per_party_left_support()
+
+    logger.info("Generating figure...")
+    fig_path = create_figure(yearly, domain_data, party_support)
+
+    logger.info("Generating report...")
+    report_path = generate_report(yearly, domain_data, party_support, fig_path)
+
+    print(f"\nReport: {report_path}")
+    print(f"Figure: {fig_path}")
+
+    # Print key findings
+    pre_years = [y for y in sorted(yearly.keys()) if y < BREAK_YEAR]
+    post_years = [y for y in sorted(yearly.keys()) if y >= BREAK_YEAR]
+
+    pre_ls = np.mean([yearly[y]["left_support"] for y in pre_years])
+    post_ls = np.mean([yearly[y]["left_support"] for y in post_years])
+    pre_cs = np.mean([yearly[y]["centrist_support"] for y in pre_years])
+    post_cs = np.mean([yearly[y]["centrist_support"] for y in post_years])
+    pre_gap = np.mean([yearly[y]["polarization_gap"] for y in pre_years])
+    post_gap = np.mean([yearly[y]["polarization_gap"] for y in post_years])
+
+    print(f"\nKey findings:")
+    print(f"  Left support:     {pre_ls:.4f} → {post_ls:.4f} (Δ = {post_ls - pre_ls:+.4f})")
+    print(f"  Centrist support: {pre_cs:.3f} → {post_cs:.3f} (Δ = {post_cs - pre_cs:+.3f})")
+    print(f"  Polarization gap: {pre_gap:.3f} → {post_gap:.3f} (Δ = {post_gap - pre_gap:+.3f})")
+    print(f"  Cohen's d (left): {cohens_d(np.array([yearly[y]['left_support'] for y in pre_years]), np.array([yearly[y]['left_support'] for y in post_years])):+.2f}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/mechanism_classification.py

@@ -0,0 +1,751 @@
+#!/usr/bin/env python3
+"""Systematic mechanism classification of right-wing motions.
+
+Classifies a stratified sample of 200 motions across 10 mechanism types
+to validate the consensus framing hypothesis. Performs chi-squared tests
+and generates a markdown report.
+
+Usage:
+    uv run python analysis/right_wing/mechanism_classification.py
+    uv run python analysis/right_wing/mechanism_classification.py --n-pre-high 25 --n-pre-low 25 --n-post-high 75 --n-post-low 75
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+import duckdb
+import numpy as np
+from scipy.stats import chi2_contingency
+
+ROOT = Path(__file__).parent.parent.parent.resolve()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+
+# ── mechanism taxonomy ───────────────────────────────────────────────────────
+
+MECHANISMS = [
+    "consensus_framing",
+    "institutional_rule_of_law",
+    "welfare_service_expansion",
+    "procedural_technical",
+    "local_constituency",
+    "coalition_alignment",
+    "symbolic_declaratory",
+    "targeted_restriction",
+    "system_dismantling",
+    "crisis_response",
+]
+
+MECHANISM_LABELS_NL = {
+    "consensus_framing": "Consensus framing (gedeeld belang)",
+    "institutional_rule_of_law": "Institutioneel/rechtsstatelijk",
+    "welfare_service_expansion": "Welzijn/dienstverlening uitbreiding",
+    "procedural_technical": "Procedureel/technisch",
+    "local_constituency": "Lokaal/regionaal",
+    "coalition_alignment": "Coalitie-afstemming",
+    "symbolic_declaratory": "Symbolisch/declaratoir",
+    "targeted_restriction": "Gerichte restrictie",
+    "system_dismantling": "Systeemontmanteling",
+    "crisis_response": "Crisisrespons",
+}
+
+
+# ── inline classifications (subagent-classified) ─────────────────────────────
+# Classification key: motion_id -> mechanism
+# Classified by reading full title + body_text of each motion.
+
+CLASSIFICATIONS: dict[int, str] = {
+    # === PRE_HIGH (25 motions, pre-2024, centrist_support_strict > 0.5) ===
+    15458: "crisis_response",           # corona tax deferral/bureaucracy
+    26477: "institutional_rule_of_law",  # Israel SOFA treaty ratification
+    9149: "consensus_framing",           # arming MQ-9 Reaper (shared defense)
+    17099: "procedural_technical",       # Brexit transition law amendment
+    4933: "procedural_technical",        # soil amendment to Environment Act
+    17751: "consensus_framing",          # zero baseline regulatory burden
+    20068: "procedural_technical",       # baseline measurement manure policy
+    16520: "consensus_framing",          # Dutch agriculture global leadership
+    17036: "welfare_service_expansion",  # defense work guarantee scheme
+    17681: "consensus_framing",          # simplify car taxation
+    14554: "procedural_technical",       # tourism cooperation quartermaster
+    21864: "procedural_technical",       # adapt manure processing definition
+    26493: "targeted_restriction",       # crackdown on asylum seeker nuisance
+    21982: "consensus_framing",          # MKB regulatory burden reduction
+    14125: "crisis_response",            # minimize corona tax bureaucracy
+    13683: "welfare_service_expansion",  # GLB influence on farmer income
+    16691: "procedural_technical",       # wild boar population management
+    15005: "procedural_technical",       # periodic franchise consultation body
+    17536: "institutional_rule_of_law",  # tackle hate preachers across Schengen
+    16999: "consensus_framing",          # prevent unfair steel competition
+    8325: "procedural_technical",        # defense materiel budget amendment
+    13370: "welfare_service_expansion",  # PGB equal position amendment
+    18030: "procedural_technical",       # highway lighting at night
+    11382: "procedural_technical",       # amendment removing generic exemption
+    18616: "procedural_technical",       # VAT e-commerce implementation law
+
+    # === PRE_LOW (25 motions, pre-2024, centrist_support_strict <= 0.5) ===
+    12411: "crisis_response",            # temporary nitrogen threshold for housing
+    22595: "crisis_response",            # shopping by appointment during lockdown
+    15772: "system_dismantling",         # prevent pension cuts (challenge ECB rate)
+    7111: "welfare_service_expansion",   # max support for fishing sector
+    25784: "targeted_restriction",       # keep coal plants open until nuclear ready
+    27731: "system_dismantling",         # BOR tax amendment (dismantle tax change)
+    15626: "crisis_response",            # corona kickstart economy scenarios
+    20215: "welfare_service_expansion",  # protect high-quality farmland
+    16430: "symbolic_declaratory",       # don't send 45bn to southern EU states
+    25982: "local_constituency",         # prevent cold sanition shrimp fishery
+    17176: "targeted_restriction",       # criminalize illegal residence
+    7054: "procedural_technical",        # stacking effect of housing market measures
+    20323: "procedural_technical",       # optical recognition for catch registration
+    18025: "system_dismantling",         # halt curriculum revision PO/VO
+    14837: "system_dismantling",         # nature policy without nitrogen fixation
+    19620: "targeted_restriction",       # natural gas-free housing never mandatory
+    21801: "consensus_framing",          # embrace Defense Vision 2035
+    19464: "crisis_response",            # keep terraces open during EK football
+    26855: "targeted_restriction",       # limit immigration inflow
+    22280: "local_constituency",         # farmer costs for societal tasks
+    20115: "symbolic_declaratory",       # defend national veto rights in EU
+    15082: "targeted_restriction",       # no residency permits for delayed procedures
+    6637: "targeted_restriction",        # protect welfare state via asylum stop
+    18691: "symbolic_declaratory",       # no extra troops to Afghanistan
+    18062: "crisis_response",            # apologies for care home corona deaths
+
+    # === POST_HIGH (75 motions, post-2024, centrist_support_strict > 0.5) ===
+    3784: "procedural_technical",        # healthcare fraud info sharing
+    10205: "procedural_technical",       # defense materiel fund budget 2025
+    10278: "coalition_alignment",        # budget amendment covering OCW package
+    25079: "consensus_framing",          # EU nitrogen standards for industry
+    2980: "targeted_restriction",        # designate NL as under migration pressure
+    10420: "crisis_response",            # citizen resilience / preparedness info
+    25092: "targeted_restriction",       # Ukrainian displaced persons pay care costs
+    25545: "institutional_rule_of_law",  # legal basis for housing corp data
+    23065: "procedural_technical",       # Justice & Security budget 2024
+    2878: "welfare_service_expansion",   # index Wbso tax scheme for R&D
+    25573: "procedural_technical",       # efficient spending nature subsidies
+    3298: "symbolic_declaratory",        # support Gaza peace plan
+    25061: "consensus_framing",          # simplify RI&E obligations for SMEs
+    4481: "consensus_framing",           # acquire control points (geo-)economic policy
+    3961: "procedural_technical",        # nuclear fleet & synergy study
+    473: "institutional_rule_of_law",    # recover UvA riot damages from demonstrators
+    10413: "consensus_framing",          # max legal room for drone training
+    974: "procedural_technical",         # WLC norm impact on housing ambition
+    24009: "procedural_technical",       # scientific basis for spray zones
+    9789: "institutional_rule_of_law",   # use temporary law on terrorism measures
+    24651: "targeted_restriction",       # slow labor migration via top summit
+    1890: "local_constituency",          # Groningen/Noord-Drenthe success stories
+    1191: "consensus_framing",           # prioritize safety in Station Agenda
+    3448: "targeted_restriction",        # reserve nitrogen space for PAS melders
+    23910: "institutional_rule_of_law",  # legal options vs antisemitic organizations
+    25566: "welfare_service_expansion",  # childminder childcare allowance fix
+    2070: "targeted_restriction",        # return plan vs uncooperative countries
+    23885: "consensus_framing",          # pension funds focus on purchasing power
+    24906: "procedural_technical",       # repair technical omissions Succession Act
+    2496: "procedural_technical",        # satellite launch capacity Netherlands
+    25582: "targeted_restriction",       # stricter asylum permit withdrawal
+    3053: "local_constituency",          # safety campus Assen development
+    1495: "procedural_technical",        # risk-based foreign funding oversight
+    10178: "procedural_technical",       # Economic Affairs budget 2025
+    1614: "procedural_technical",        # nuclear sector training needs inventory
+    23441: "consensus_framing",          # redirect equal opportunity budget to quality
+    3569: "consensus_framing",           # infrastructure investment counted as NATO
+    10285: "procedural_technical",       # States General budget 2025
+    23058: "procedural_technical",       # OCW budget 2024
+    3287: "procedural_technical",        # inform parliament on humanitarian spending
+    10434: "consensus_framing",          # integral future-proof media system
+    10089: "procedural_technical",       # Asylum & Migration budget 2025
+    22706: "consensus_framing",          # entrepreneur accord process
+    3877: "institutional_rule_of_law",   # safety of converted asylum seekers
+    25062: "consensus_framing",          # workable hazardous substances for SMEs
+    3687: "targeted_restriction",        # EVRM interpretation protocol for asylum
+    25166: "procedural_technical",       # detection dogs in prisons
+    4618: "procedural_technical",        # Housing budget amendment
+    3468: "institutional_rule_of_law",   # expand riot police weapons/defense
+    24632: "institutional_rule_of_law",  # police access fatbike menu for enforcement
+    25451: "symbolic_declaratory",       # calculate Palestine Authority pay-to-slay
+    2351: "targeted_restriction",        # max 1yr prison for undesired declaration
+    4227: "consensus_framing",           # Nijkerk bridge as strategic infrastructure
+    22853: "consensus_framing",          # accelerate North Sea gas extraction
+    9884: "procedural_technical",        # innovation contribution to emission reduction
+    1428: "consensus_framing",           # liberalize trade with Canada/Mexico
+    3629: "symbolic_declaratory",        # modernize UN Refugee Convention
+    1572: "local_constituency",          # wolf attack impact mapping
+    25493: "procedural_technical",       # defense materiel fund budget amendment
+    1359: "procedural_technical",        # firework ban damage compensation estimate
+    2252: "procedural_technical",        # municipal fund budget amendment
+    23605: "procedural_technical",       # PAS melders legal verification process
+    3760: "consensus_framing",           # Defense Readiness Act submission
+    1005: "consensus_framing",           # EU import tariffs to support entrepreneurs
+    10110: "coalition_alignment",        # budget amendment covering OCW package
+    23301: "consensus_framing",          # international tendering military projects
+    24046: "symbolic_declaratory",       # abstain from WHA accord (pandemic treaty)
+    651: "welfare_service_expansion",    # agri nature management for Natuurnetwerk
+    1491: "targeted_restriction",        # max wolf population Netherlands
+    25606: "targeted_restriction",       # prevent wolf habituation to humans
+    313: "procedural_technical",         # temporarily drop pre-filled tax return
+    24008: "consensus_framing",          # EU approval frameworks for green agents
+    754: "targeted_restriction",         # expel third-country nationals from Ukraine
+    25469: "targeted_restriction",       # EU return hubs for asylum seekers
+    25091: "targeted_restriction",       # stop asylum if travel to home country
+
+    # === POST_LOW (75 motions, post-2024, centrist_support_strict <= 0.5) ===
+    2170: "institutional_rule_of_law",   # prison renovation budget amendment
+    22792: "procedural_technical",       # investigate French espionage at Saab
+    10597: "institutional_rule_of_law",  # remove third observer from preventive search
+    23013: "institutional_rule_of_law",  # antisemitism combating work plan budget
+    3472: "institutional_rule_of_law",   # minimum sentences for violence vs aid workers
+    2014: "system_dismantling",          # limit asylum appeals to single instance
+    920: "procedural_technical",         # transitional facility real estate box 3
+    2143: "welfare_service_expansion",   # campaign working in healthcare
+    688: "system_dismantling",           # reject Tromsø Convention accession
+    2290: "system_dismantling",          # repeal municipal asylum task law
+    4497: "targeted_restriction",        # stop funding terrorist organizations
+    3823: "symbolic_declaratory",        # child attachment not against family return
+    23141: "institutional_rule_of_law",  # deploy KMar for domestic security
+    4436: "institutional_rule_of_law",   # standard aggravated sentence for aid worker violence
+    25616: "targeted_restriction",       # scrap municipal status holder housing task
+    2662: "institutional_rule_of_law",   # prevent NL germline modification tech export
+    23287: "institutional_rule_of_law",  # community service ban for violence vs police
+    4660: "consensus_framing",           # defense cooperation with Israel
+    4761: "targeted_restriction",        # denaturalization and forced remigration
+    2264: "institutional_rule_of_law",   # recover UvA demo damages from perpetrators
+    4394: "institutional_rule_of_law",   # beanbag air-pressure weapon for police pilot
+    1691: "targeted_restriction",        # no penal orders for criminal asylum seekers
+    10601: "targeted_restriction",       # ban NGOs in human smuggling chain
+    4089: "targeted_restriction",        # deny entry to Al-Hol camp persons
+    23206: "procedural_technical",        # map NATO defense product leakage
+    22676: "institutional_rule_of_law",  # offensive vs porn industry abuses
+    115: "system_dismantling",           # oppose EU 90% emission reduction target
+    3951: "consensus_framing",           # nuclear energy in CO2-low energy mix post-COP30
+    1375: "targeted_restriction",        # enforce status holder housing priority ban
+    3090: "targeted_restriction",        # ban Muslim Brotherhood in Netherlands
+    24650: "procedural_technical",       # cash acceptance obligation for small payments
+    1772: "consensus_framing",           # legislation for top-10 business climate
+    3678: "system_dismantling",          # total asylum stop and family reunification stop
+    1692: "institutional_rule_of_law",   # remove penal orders for serious crimes
+    24077: "symbolic_declaratory",       # investigate Fatah role in Oct 7 attack
+    349: "institutional_rule_of_law",    # increased penalty for organ removal/sexual exploitation
+    9769: "targeted_restriction",        # return Syrians to rebuild their country
+    4656: "symbolic_declaratory",        # no Ukraine NATO accession
+    23984: "system_dismantling",         # don't raise eco-regulation requirements
+    2168: "institutional_rule_of_law",   # prison budget for JeugdzorgPlus takeover
+    4443: "institutional_rule_of_law",   # 200% sentence increase for violence vs public servants
+    4489: "procedural_technical",        # fishing disturbance impact on scoter
+    10290: "targeted_restriction",       # concrete migration project for JBZ Council
+    4071: "targeted_restriction",        # investigate housing fraud by status holders
+    4088: "targeted_restriction",        # agreements with third countries on asylum
+    1507: "system_dismantling",          # empirical nature data as alternative to KDW
+    2870: "procedural_technical",        # FGR transitional law amendment
+    1912: "system_dismantling",          # repeal Spreidingswet
+    22658: "symbolic_declaratory",       # no Dutch troops to Ukraine
+    10288: "targeted_restriction",       # prepare Syrian return plan
+    4080: "institutional_rule_of_law",   # research heavier forced re-education
+    1847: "targeted_restriction",        # return hub for hopeless asylum seekers
+    23127: "system_dismantling",         # restore 120/130 km/h speed limit
+    4367: "targeted_restriction",        # no relaxation of EU accession for Ukraine
+    9790: "targeted_restriction",        # no cooperation with IS returnees
+    4150: "procedural_technical",        # fishing net selectivity/safety research
+    741: "targeted_restriction",         # blue card minimum salary 1.3x average
+    1705: "consensus_framing",           # reduce regulatory burden for industry
+    1831: "consensus_framing",           # precautionary principle proportionality
+    10600: "targeted_restriction",       # ban NGOs active in migrant smuggling
+    9767: "targeted_restriction",        # no compulsory asylum reception in distribution decision
+    3830: "system_dismantling",          # stop patronizing policy toward adults
+    4221: "system_dismantling",          # overhead norm for public broadcasting
+    3354: "institutional_rule_of_law",   # raise 3D-printed firearms max penalty
+    9977: "symbolic_declaratory",        # oppose abolishing EU veto right
+    898: "consensus_framing",            # simplify Omnibus and CSDDD
+    24848: "system_dismantling",         # repeal Spreidingswet ASAP
+    756: "targeted_restriction",         # temporary stop on family reunification
+    24358: "institutional_rule_of_law",  # increase prison capacity via earlier lockup
+    4309: "institutional_rule_of_law",   # targeted demographic policy for enforcement
+    10167: "local_constituency",         # pilot projects for crayfish control
+    23633: "procedural_technical",       # adjust parliament bell ringing
+    23030: "targeted_restriction",       # no compulsory asylum places in distribution
+    1959: "system_dismantling",          # no ban on plastic-containing wet wipes
+    23454: "procedural_technical",        # legal analysis of pension transition risks
+}
+
+
+# ── sampling ─────────────────────────────────────────────────────────────────
+
+# Deterministic sample: 200 motions used for inline classification.
+# Motion IDs fixed to enable reproducible classification results.
+DETERMINISTIC_SAMPLE_IDS = {
+    "pre_high": [4933, 8325, 9149, 11382, 13370, 13683, 14125, 14554, 15005, 15458, 16520, 16691, 16999, 17036, 17099, 17536, 17681, 17751, 18030, 18616, 20068, 21864, 21982, 26477, 26493],
+    "pre_low": [6637, 7054, 7111, 12411, 14837, 15082, 15626, 15772, 16430, 17176, 18025, 18062, 18691, 19464, 19620, 20115, 20215, 20323, 21801, 22280, 22595, 25784, 25982, 26855, 27731],
+    "post_high": [313, 473, 651, 754, 974, 1005, 1191, 1359, 1428, 1491, 1495, 1572, 1614, 1890, 2070, 2252, 2351, 2496, 2878, 2980, 3053, 3287, 3298, 3448, 3468, 3569, 3629, 3687, 3760, 3784, 3877, 3961, 4227, 4481, 4618, 9789, 9884, 10089, 10110, 10178, 10205, 10278, 10285, 10413, 10420, 10434, 22706, 22853, 23058, 23065, 23301, 23441, 23605, 23885, 23910, 24008, 24009, 24046, 24632, 24651, 24906, 25061, 25062, 25079, 25091, 25092, 25166, 25451, 25469, 25493, 25545, 25566, 25573, 25582, 25606],
+    "post_low": [115, 349, 688, 741, 756, 898, 920, 1375, 1507, 1691, 1692, 1705, 1772, 1831, 1847, 1912, 1959, 2014, 2143, 2168, 2170, 2264, 2290, 2662, 2870, 3090, 3354, 3472, 3678, 3823, 3830, 3951, 4071, 4080, 4088, 4089, 4150, 4221, 4309, 4367, 4394, 4436, 4443, 4489, 4497, 4656, 4660, 4761, 9767, 9769, 9790, 9977, 10167, 10288, 10290, 10597, 10600, 10601, 22658, 22676, 22792, 23013, 23030, 23127, 23141, 23206, 23287, 23454, 23633, 23984, 24077, 24358, 24650, 24848, 25616],
+}
+
+
+def sample_motions(
+    db_path: str,
+    n_pre_high: int = 25,
+    n_pre_low: int = 25,
+    n_post_high: int = 75,
+    n_post_low: int = 75,
+    seed: int = 42,
+) -> list[dict[str, Any]]:
+    """Deterministic sample of right_wing_motions JOIN motions using known IDs."""
+    all_ids = []
+    stratum_map = {}
+    for stratum, ids in DETERMINISTIC_SAMPLE_IDS.items():
+        for mid in ids:
+            all_ids.append(mid)
+            stratum_map[mid] = stratum
+
+    con = duckdb.connect(db_path)
+    try:
+        placeholders = ",".join("?" for _ in all_ids)
+        rows = con.execute(
+            f"""
+            SELECT r.motion_id, m.title, m.body_text, r.year, r.centrist_support_strict
+            FROM right_wing_motions r
+            JOIN motions m ON r.motion_id = m.id
+            WHERE r.motion_id IN ({placeholders})
+            ORDER BY r.motion_id
+            """,
+            all_ids,
+        ).fetchall()
+
+        return [
+            {
+                "motion_id": r[0],
+                "title": r[1] or "",
+                "body_text": r[2] or "",
+                "year": r[3],
+                "centrist_support_strict": r[4],
+                "stratum": stratum_map.get(r[0], "unknown"),
+            }
+            for r in rows
+        ]
+    finally:
+        con.close()
+
+
+# ── analysis ─────────────────────────────────────────────────────────────────
+
+def compute_distribution(
+    sample: list[dict[str, Any]],
+    classifications: dict[int, str],
+) -> dict[str, Any]:
+    """Compute mechanism distribution by period and support level."""
+    # Build distribution table
+    groups: dict[str, Counter[str]] = {
+        "pre_high": Counter(),
+        "pre_low": Counter(),
+        "post_high": Counter(),
+        "post_low": Counter(),
+    }
+
+    classified = 0
+    unclassified = 0
+    for motion in sample:
+        mid = motion["motion_id"]
+        stratum = motion["stratum"]
+        mechanism = classifications.get(mid)
+        if mechanism and mechanism in MECHANISMS:
+            groups[stratum][mechanism] += 1
+            classified += 1
+        else:
+            unclassified += 1
+            groups[stratum]["unclassified"] = groups[stratum].get("unclassified", 0) + 1  # type: ignore[index]
+
+    # Build contingency table for chi-squared: period × mechanism
+    # Consolidate: pre = pre_high + pre_low, post = post_high + post_low
+    pre_counts = groups["pre_high"] + groups["pre_low"]
+    post_counts = groups["post_high"] + groups["post_low"]
+
+    # Contingency table: rows=mechanisms, cols=[pre, post]
+    contingency_pre_post = []
+    row_labels = []
+    for mech in MECHANISMS:
+        row = [pre_counts.get(mech, 0), post_counts.get(mech, 0)]
+        if sum(row) > 0:
+            contingency_pre_post.append(row)
+            row_labels.append(mech)
+
+    chi2_result = None
+    if len(contingency_pre_post) >= 2:
+        arr = np.array(contingency_pre_post)
+        # Only include rows/cols with sufficient data
+        if arr.sum() > 0 and arr.shape[0] >= 2 and arr.shape[1] >= 2:
+            try:
+                chi2, pval, dof, expected = chi2_contingency(arr)
+                chi2_result = {
+                    "chi2": float(chi2),
+                    "p_value": float(pval),
+                    "dof": int(dof),
+                    "significant": bool(pval < 0.05),
+                }
+            except ValueError:
+                chi2_result = {"error": "Invalid contingency table"}
+
+    # High vs low support within post-2024 only
+    post_high_counts = groups["post_high"]
+    post_low_counts = groups["post_low"]
+    contingency_hl = []
+    hl_labels = []
+    for mech in MECHANISMS:
+        row = [post_high_counts.get(mech, 0), post_low_counts.get(mech, 0)]
+        if sum(row) > 0:
+            contingency_hl.append(row)
+            hl_labels.append(mech)
+
+    chi2_hl_result = None
+    if len(contingency_hl) >= 2:
+        arr_hl = np.array(contingency_hl)
+        if arr_hl.sum() > 0 and arr_hl.shape[0] >= 2 and arr_hl.shape[1] >= 2:
+            try:
+                chi2, pval, dof, expected = chi2_contingency(arr_hl)
+                chi2_hl_result = {
+                    "chi2": float(chi2),
+                    "p_value": float(pval),
+                    "dof": int(dof),
+                    "significant": bool(pval < 0.05),
+                }
+            except ValueError:
+                chi2_hl_result = {"error": "Invalid contingency table"}
+
+    # Specific test: consensus_framing in post_high vs post_low
+    cf_post_high = post_high_counts.get("consensus_framing", 0)
+    cf_post_low = post_low_counts.get("consensus_framing", 0)
+    total_post_high = sum(post_high_counts.values())
+    total_post_low = sum(post_low_counts.values())
+    cf_ratio_high = cf_post_high / total_post_high if total_post_high else 0
+    cf_ratio_low = cf_post_low / total_post_low if total_post_low else 0
+
+    # Fisher-style 2x2 for consensus_framing in post: high vs low
+    non_cf_post_high = total_post_high - cf_post_high
+    non_cf_post_low = total_post_low - cf_post_low
+    cf_2x2 = np.array([[cf_post_high, non_cf_post_high], [cf_post_low, non_cf_post_low]])
+    cf_chi2_result = None
+    if cf_2x2.min() >= 0:
+        try:
+            chi2, pval, dof, _ = chi2_contingency(cf_2x2)
+            cf_chi2_result = {
+                "chi2": float(chi2),
+                "p_value": float(pval),
+                "dof": int(dof),
+                "significant": bool(pval < 0.05),
+                "cf_ratio_high": round(cf_ratio_high, 4),
+                "cf_ratio_low": round(cf_ratio_low, 4),
+                "cf_count_high": cf_post_high,
+                "cf_count_low": cf_post_low,
+                "total_high": total_post_high,
+                "total_low": total_post_low,
+            }
+        except ValueError:
+            cf_chi2_result = {"error": "Invalid 2x2 table"}
+
+    # Pre vs post consensus framing
+    cf_pre = pre_counts.get("consensus_framing", 0)
+    cf_post = post_counts.get("consensus_framing", 0)
+    total_pre = sum(pre_counts.values())
+    total_post = sum(post_counts.values())
+
+    return {
+        "sample_size": len(sample),
+        "classified": classified,
+        "unclassified": unclassified,
+        "distribution": {s: dict(g.most_common()) for s, g in groups.items()},
+        "mechanism_totals_pre": dict(pre_counts.most_common()),
+        "mechanism_totals_post": dict(post_counts.most_common()),
+        "chi2_pre_vs_post": chi2_result,
+        "chi2_post_high_vs_low": chi2_hl_result,
+        "consensus_framing_test": cf_chi2_result,
+        "cf_pre_post": {
+            "cf_pre": cf_pre,
+            "cf_post": cf_post,
+            "total_pre": total_pre,
+            "total_post": total_post,
+            "ratio_pre": round(cf_pre / total_pre, 4) if total_pre else 0,
+            "ratio_post": round(cf_post / total_post, 4) if total_post else 0,
+        },
+    }
+
+
+# ── report generation ────────────────────────────────────────────────────────
+
+def generate_report(results: dict[str, Any], output_path: str) -> None:
+    """Generate mechanism classification markdown report."""
+    dist = results["distribution"]
+    cf_test = results["consensus_framing_test"]
+    cf_pp = results["cf_pre_post"]
+
+    lines = [
+        "# Mechanism Classification Report",
+        "",
+        f"**Sample:** {results['sample_size']} motions (stratified: 50 pre-2024, 150 post-2024)",
+        f"**Classified:** {results['classified']} motions | **Unclassified:** {results['unclassified']}",
+        "",
+        "## 1. Mechanism Distribution by Group",
+        "",
+        "### Pre-2024, High Centrist Support (CS > 0.5)",
+        "",
+        "| Mechanism | Count | Pct |",
+        "|-----------|-------|-----|",
+    ]
+
+    pre_high = dist.get("pre_high", {})
+    pre_high_total = sum(pre_high.values())
+    for mech in MECHANISMS:
+        cnt = pre_high.get(mech, 0)
+        pct = f"{cnt / pre_high_total * 100:.1f}%" if pre_high_total else "0%"
+        label = MECHANISM_LABELS_NL.get(mech, mech)
+        lines.append(f"| {label} | {cnt} | {pct} |")
+    lines.append(f"| **Total** | **{pre_high_total}** | **100%** |")
+
+    lines.extend([
+        "",
+        "### Pre-2024, Low Centrist Support (CS <= 0.5)",
+        "",
+        "| Mechanism | Count | Pct |",
+        "|-----------|-------|-----|",
+    ])
+    pre_low = dist.get("pre_low", {})
+    pre_low_total = sum(pre_low.values())
+    for mech in MECHANISMS:
+        cnt = pre_low.get(mech, 0)
+        pct = f"{cnt / pre_low_total * 100:.1f}%" if pre_low_total else "0%"
+        label = MECHANISM_LABELS_NL.get(mech, mech)
+        lines.append(f"| {label} | {cnt} | {pct} |")
+    lines.append(f"| **Total** | **{pre_low_total}** | **100%** |")
+
+    lines.extend([
+        "",
+        "### Post-2024, High Centrist Support (CS > 0.5)",
+        "",
+        "| Mechanism | Count | Pct |",
+        "|-----------|-------|-----|",
+    ])
+    post_high = dist.get("post_high", {})
+    post_high_total = sum(post_high.values())
+    for mech in MECHANISMS:
+        cnt = post_high.get(mech, 0)
+        pct = f"{cnt / post_high_total * 100:.1f}%" if post_high_total else "0%"
+        label = MECHANISM_LABELS_NL.get(mech, mech)
+        lines.append(f"| {label} | {cnt} | {pct} |")
+    lines.append(f"| **Total** | **{post_high_total}** | **100%** |")
+
+    lines.extend([
+        "",
+        "### Post-2024, Low Centrist Support (CS <= 0.5)",
+        "",
+        "| Mechanism | Count | Pct |",
+        "|-----------|-------|-----|",
+    ])
+    post_low = dist.get("post_low", {})
+    post_low_total = sum(post_low.values())
+    for mech in MECHANISMS:
+        cnt = post_low.get(mech, 0)
+        pct = f"{cnt / post_low_total * 100:.1f}%" if post_low_total else "0%"
+        label = MECHANISM_LABELS_NL.get(mech, mech)
+        lines.append(f"| {label} | {cnt} | {pct} |")
+    lines.append(f"| **Total** | **{post_low_total}** | **100%** |")
+
+    # Summary: Pre vs Post
+    lines.extend([
+        "",
+        "## 2. Consolidated Pre vs Post-2024 Distribution",
+        "",
+        "| Mechanism | Pre-2024 | Pct Pre | Post-2024 | Pct Post |",
+        "|-----------|----------|---------|-----------|----------|",
+    ])
+    pre_cons = results["mechanism_totals_pre"]
+    post_cons = results["mechanism_totals_post"]
+    pre_total = sum(pre_cons.values())
+    post_total = sum(post_cons.values())
+    for mech in MECHANISMS:
+        pre_cnt = pre_cons.get(mech, 0)
+        post_cnt = post_cons.get(mech, 0)
+        pre_pct = f"{pre_cnt / pre_total * 100:.1f}%" if pre_total else "0%"
+        post_pct = f"{post_cnt / post_total * 100:.1f}%" if post_total else "0%"
+        label = MECHANISM_LABELS_NL.get(mech, mech)
+        lines.append(f"| {label} | {pre_cnt} | {pre_pct} | {post_cnt} | {post_pct} |")
+    lines.append(f"| **Total** | **{pre_total}** | **100%** | **{post_total}** | **100%** |")
+
+    # Consensus framing focus
+    lines.extend([
+        "",
+        "## 3. Consensus Framing Hypothesis Test",
+        "",
+        f"**H0:** Consensus framing is equally common in high-support and low-support post-2024 motions.",
+        f"**H1:** Consensus framing is significantly more common in high-support post-2024 motions.",
+        "",
+    ])
+    if cf_test and "error" not in cf_test:
+        lines.append(f"- Consensus framing in post-2024 HIGH: {cf_test['cf_count_high']}/{cf_test['total_high']} ({cf_test['cf_ratio_high']:.1%})")
+        lines.append(f"- Consensus framing in post-2024 LOW: {cf_test['cf_count_low']}/{cf_test['total_low']} ({cf_test['cf_ratio_low']:.1%})")
+        lines.append(f"- χ²(1) = {cf_test['chi2']:.3f}, p = {cf_test['p_value']:.4f}")
+        if cf_test["significant"]:
+            lines.append(f"- **Result: Significant difference (p < 0.05). Consensus framing IS more common in high-support post-2024 motions.**")
+        else:
+            lines.append(f"- **Result: Not significant (p >= 0.05). Cannot reject the null.**")
+    else:
+        lines.append("- Consensus framing test could not be performed (insufficient data).")
+
+    lines.extend([
+        "",
+        f"- Consensus framing pre-2024: {cf_pp['cf_pre']}/{cf_pp['total_pre']} ({cf_pp['ratio_pre']:.1%})",
+        f"- Consensus framing post-2024: {cf_pp['cf_post']}/{cf_pp['total_post']} ({cf_pp['ratio_post']:.1%})",
+    ])
+
+    # Chi-squared tests
+    chi2_all = results["chi2_pre_vs_post"]
+    if chi2_all and "error" not in chi2_all:
+        lines.extend([
+            "",
+            "## 4. Chi-Squared Test: Period × Mechanism",
+            "",
+            f"- χ²({chi2_all['dof']}) = {chi2_all['chi2']:.3f}, p = {chi2_all['p_value']:.4f}",
+            f"- {'Significant' if chi2_all['significant'] else 'Not significant'} difference in mechanism distribution between pre and post-2024.",
+        ])
+
+    chi2_hl = results["chi2_post_high_vs_low"]
+    if chi2_hl and "error" not in chi2_hl:
+        lines.extend([
+            "",
+            "## 5. Chi-Squared Test: Support Level × Mechanism (Post-2024)",
+            "",
+            f"- χ²({chi2_hl['dof']}) = {chi2_hl['chi2']:.3f}, p = {chi2_hl['p_value']:.4f}",
+            f"- {'Significant' if chi2_hl['significant'] else 'Not significant'} difference in mechanism distribution between high and low support post-2024 motions.",
+        ])
+
+    lines.extend([
+        "",
+        "## 6. Key Findings",
+        "",
+    ])
+
+    # Compute and report key findings
+    # Which mechanisms dominate in high-support post-2024?
+    post_high_sorted = sorted(post_high.items(), key=lambda x: x[1], reverse=True)
+    post_low_sorted = sorted(post_low.items(), key=lambda x: x[1], reverse=True)
+
+    lines.append("### Top 3 mechanisms in post-2024 HIGH-support motions:")
+    for mech, cnt in post_high_sorted[:3]:
+        label = MECHANISM_LABELS_NL.get(mech, mech)
+        pct = cnt / post_high_total * 100
+        lines.append(f"- {label}: {cnt} ({pct:.1f}%)")
+
+    lines.append("")
+    lines.append("### Top 3 mechanisms in post-2024 LOW-support motions:")
+    for mech, cnt in post_low_sorted[:3]:
+        label = MECHANISM_LABELS_NL.get(mech, mech)
+        pct = cnt / post_low_total * 100
+        lines.append(f"- {label}: {cnt} ({pct:.1f}%)")
+
+    # Shift analysis
+    lines.extend([
+        "",
+        "### Mechanism shifts from pre to post-2024",
+        "",
+        "| Mechanism | Pre Pct | Post Pct | Δ |",
+        "|-----------|---------|----------|---|",
+    ])
+    for mech in MECHANISMS:
+        pre_cnt = pre_cons.get(mech, 0)
+        post_cnt = post_cons.get(mech, 0)
+        pre_pct = pre_cnt / pre_total * 100 if pre_total else 0
+        post_pct = post_cnt / post_total * 100 if post_total else 0
+        delta = post_pct - pre_pct
+        label = MECHANISM_LABELS_NL.get(mech, mech)
+        lines.append(f"| {label} | {pre_pct:.1f}% | {post_pct:.1f}% | {delta:+.1f}% |")
+
+    lines.extend([
+        "",
+        "## 7. Conclusion",
+        "",
+    ])
+
+    # Interpretation
+    cf_consensus = ""
+    if cf_test and "error" not in cf_test:
+        if cf_test["significant"] and cf_test["cf_ratio_high"] > cf_test["cf_ratio_low"]:
+            cf_consensus = (
+                f"The consensus framing hypothesis **is supported**: consensus framing motions "
+                f"are {cf_test['cf_ratio_high']:.1%} of high-support post-2024 motions vs "
+                f"{cf_test['cf_ratio_low']:.1%} of low-support post-2024 motions "
+                f"(χ² = {cf_test['chi2']:.3f}, p = {cf_test['p_value']:.4f})."
+            )
+        else:
+            cf_consensus = (
+                f"The consensus framing hypothesis **is not supported**: no significant difference "
+                f"between high ({cf_test['cf_ratio_high']:.1%}) and low ({cf_test['cf_ratio_low']:.1%}) "
+                f"support post-2024 motions (p = {cf_test['p_value']:.4f})."
+            )
+
+    lines.append(cf_consensus)
+    lines.append("")
+    lines.append("### Limitations")
+    lines.append("- Sample: 200 motions (50 pre, 150 post) — may not capture rare mechanisms")
+    lines.append("- Single-classifier: all motions classified by one subagent (inline), no inter-rater validation")
+    lines.append("- Binary support threshold: CS > 0.5 vs <= 0.5 may oversimplify the support spectrum")
+    lines.append("- Mechanism assignment: single primary mechanism per motion; some motions span multiple categories")
+
+    # Write output
+    out_path = Path(output_path)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    print(f"Report written to {out_path}")
+
+
+# ── main ─────────────────────────────────────────────────────────────────────
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Systematic mechanism classification")
+    parser.add_argument("--db", default="data/motions.db", help="Path to DuckDB database")
+    parser.add_argument("--n-pre-high", type=int, default=25)
+    parser.add_argument("--n-pre-low", type=int, default=25)
+    parser.add_argument("--n-post-high", type=int, default=75)
+    parser.add_argument("--n-post-low", type=int, default=75)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--output", default="reports/overton_window/mechanism_classification.md")
+    parser.add_argument("--save-classifications", help="Save classifications JSON to path")
+    args = parser.parse_args()
+
+    # Sample motions
+    sample = sample_motions(
+        db_path=args.db,
+        n_pre_high=args.n_pre_high,
+        n_pre_low=args.n_pre_low,
+        n_post_high=args.n_post_high,
+        n_post_low=args.n_post_low,
+        seed=args.seed,
+    )
+    print(f"Sampled {len(sample)} motions")
+
+    # Optional: save classifications mapping
+    if args.save_classifications:
+        class_path = Path(args.save_classifications)
+        class_path.parent.mkdir(parents=True, exist_ok=True)
+        class_path.write_text(json.dumps(CLASSIFICATIONS, indent=2, ensure_ascii=False), encoding="utf-8")
+        print(f"Classifications saved to {class_path}")
+
+    # Compute distribution
+    results = compute_distribution(sample, CLASSIFICATIONS)
+    print(f"Classified: {results['classified']}, Unclassified: {results['unclassified']}")
+
+    # Generate report
+    generate_report(results, args.output)
+
+    # Print summary to stdout
+    cf_test = results["consensus_framing_test"]
+    if cf_test and "error" not in cf_test:
+        print(f"\nConsensus Framing Test:")
+        print(f"  Post-2024 HIGH: {cf_test['cf_count_high']}/{cf_test['total_high']} = {cf_test['cf_ratio_high']:.1%}")
+        print(f"  Post-2024 LOW:  {cf_test['cf_count_low']}/{cf_test['total_low']} = {cf_test['cf_ratio_low']:.1%}")
+        print(f"  χ² = {cf_test['chi2']:.3f}, p = {cf_test['p_value']:.4f} ({'SIGNIFICANT' if cf_test['significant'] else 'NOT significant'})")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/mechanism_validation.py

@@ -0,0 +1,946 @@
+#!/usr/bin/env python3
+"""Mechanism classification validation with a second classifier.
+
+Computes inter-rater reliability (Cohen's kappa) between the original inline
+classifications and a second LLM-based classification using a different prompt
+template and (optionally) a different model.
+
+Usage:
+    uv run python analysis/right_wing/mechanism_validation.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+import time
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Any
+
+import duckdb
+
+ROOT = Path(__file__).parent.parent.parent.resolve()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from ai_provider import ProviderError, chat_completion
+from analysis.config import config
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+# ── mechanism taxonomy ───────────────────────────────────────────────────────
+
+MECHANISMS = [
+    "consensus_framing",
+    "institutional_rule_of_law",
+    "welfare_service_expansion",
+    "procedural_technical",
+    "local_constituency",
+    "coalition_alignment",
+    "symbolic_declaratory",
+    "targeted_restriction",
+    "system_dismantling",
+    "crisis_response",
+]
+
+MECHANISM_LABELS_NL = {
+    "consensus_framing": "Consensus framing (gedeeld belang)",
+    "institutional_rule_of_law": "Institutioneel/rechtsstatelijk",
+    "welfare_service_expansion": "Welzijn/dienstverlening uitbreiding",
+    "procedural_technical": "Procedureel/technisch",
+    "local_constituency": "Lokaal/regionaal",
+    "coalition_alignment": "Coalitie-afstemming",
+    "symbolic_declaratory": "Symbolisch/declaratoir",
+    "targeted_restriction": "Gerichte restrictie",
+    "system_dismantling": "Systeemontmanteling",
+    "crisis_response": "Crisisrespons",
+}
+
+MECHANISM_LABELS_EN = {
+    "consensus_framing": "Consensus framing / shared interest",
+    "institutional_rule_of_law": "Institutional / rule of law",
+    "welfare_service_expansion": "Welfare / service expansion",
+    "procedural_technical": "Procedural / technical",
+    "local_constituency": "Local / regional constituency",
+    "coalition_alignment": "Coalition alignment",
+    "symbolic_declaratory": "Symbolic / declaratory",
+    "targeted_restriction": "Targeted restriction",
+    "system_dismantling": "System dismantling",
+    "crisis_response": "Crisis response",
+}
+
+# Original inline classifications (from mechanism_classification.py)
+ORIGINAL_CLASSIFICATIONS: dict[int, str] = {
+    15458: "crisis_response",
+    26477: "institutional_rule_of_law",
+    9149: "consensus_framing",
+    17099: "procedural_technical",
+    4933: "procedural_technical",
+    17751: "consensus_framing",
+    20068: "procedural_technical",
+    16520: "consensus_framing",
+    17036: "welfare_service_expansion",
+    17681: "consensus_framing",
+    14554: "procedural_technical",
+    21864: "procedural_technical",
+    26493: "targeted_restriction",
+    21982: "consensus_framing",
+    14125: "crisis_response",
+    13683: "welfare_service_expansion",
+    16691: "procedural_technical",
+    15005: "procedural_technical",
+    17536: "institutional_rule_of_law",
+    16999: "consensus_framing",
+    8325: "procedural_technical",
+    13370: "welfare_service_expansion",
+    18030: "procedural_technical",
+    11382: "procedural_technical",
+    18616: "procedural_technical",
+    12411: "crisis_response",
+    22595: "crisis_response",
+    15772: "system_dismantling",
+    7111: "welfare_service_expansion",
+    25784: "targeted_restriction",
+    27731: "system_dismantling",
+    15626: "crisis_response",
+    20215: "welfare_service_expansion",
+    16430: "symbolic_declaratory",
+    25982: "local_constituency",
+    17176: "targeted_restriction",
+    7054: "procedural_technical",
+    20323: "procedural_technical",
+    18025: "system_dismantling",
+    14837: "system_dismantling",
+    19620: "targeted_restriction",
+    21801: "consensus_framing",
+    19464: "crisis_response",
+    26855: "targeted_restriction",
+    22280: "local_constituency",
+    20115: "symbolic_declaratory",
+    15082: "targeted_restriction",
+    6637: "targeted_restriction",
+    18691: "symbolic_declaratory",
+    18062: "crisis_response",
+    3784: "procedural_technical",
+    10205: "procedural_technical",
+    10278: "coalition_alignment",
+    25079: "consensus_framing",
+    2980: "targeted_restriction",
+    10420: "crisis_response",
+    25092: "targeted_restriction",
+    25545: "institutional_rule_of_law",
+    23065: "procedural_technical",
+    2878: "welfare_service_expansion",
+    25573: "procedural_technical",
+    3298: "symbolic_declaratory",
+    25061: "consensus_framing",
+    4481: "consensus_framing",
+    3961: "procedural_technical",
+    473: "institutional_rule_of_law",
+    10413: "consensus_framing",
+    974: "procedural_technical",
+    24009: "procedural_technical",
+    9789: "institutional_rule_of_law",
+    24651: "targeted_restriction",
+    1890: "local_constituency",
+    1191: "consensus_framing",
+    3448: "targeted_restriction",
+    23910: "institutional_rule_of_law",
+    25566: "welfare_service_expansion",
+    2070: "targeted_restriction",
+    23885: "consensus_framing",
+    24906: "procedural_technical",
+    2496: "procedural_technical",
+    25582: "targeted_restriction",
+    3053: "local_constituency",
+    1495: "procedural_technical",
+    10178: "procedural_technical",
+    1614: "procedural_technical",
+    23441: "consensus_framing",
+    3569: "consensus_framing",
+    10285: "procedural_technical",
+    23058: "procedural_technical",
+    3287: "procedural_technical",
+    10434: "consensus_framing",
+    10089: "procedural_technical",
+    22706: "consensus_framing",
+    3877: "institutional_rule_of_law",
+    25062: "consensus_framing",
+    3687: "targeted_restriction",
+    25166: "procedural_technical",
+    4618: "procedural_technical",
+    3468: "institutional_rule_of_law",
+    24632: "institutional_rule_of_law",
+    25451: "symbolic_declaratory",
+    2351: "targeted_restriction",
+    4227: "consensus_framing",
+    22853: "consensus_framing",
+    9884: "procedural_technical",
+    1428: "consensus_framing",
+    3629: "symbolic_declaratory",
+    1572: "local_constituency",
+    25493: "procedural_technical",
+    1359: "procedural_technical",
+    2252: "procedural_technical",
+    23605: "procedural_technical",
+    3760: "consensus_framing",
+    1005: "consensus_framing",
+    10110: "coalition_alignment",
+    23301: "consensus_framing",
+    24046: "symbolic_declaratory",
+    651: "welfare_service_expansion",
+    1491: "targeted_restriction",
+    25606: "targeted_restriction",
+    313: "procedural_technical",
+    24008: "consensus_framing",
+    754: "targeted_restriction",
+    25469: "targeted_restriction",
+    25091: "targeted_restriction",
+    2170: "institutional_rule_of_law",
+    22792: "procedural_technical",
+    10597: "institutional_rule_of_law",
+    23013: "institutional_rule_of_law",
+    3472: "institutional_rule_of_law",
+    2014: "system_dismantling",
+    920: "procedural_technical",
+    2143: "welfare_service_expansion",
+    688: "system_dismantling",
+    2290: "system_dismantling",
+    4497: "targeted_restriction",
+    3823: "symbolic_declaratory",
+    23141: "institutional_rule_of_law",
+    4436: "institutional_rule_of_law",
+    25616: "targeted_restriction",
+    2662: "institutional_rule_of_law",
+    23287: "institutional_rule_of_law",
+    4660: "consensus_framing",
+    4761: "targeted_restriction",
+    2264: "institutional_rule_of_law",
+    4394: "institutional_rule_of_law",
+    1691: "targeted_restriction",
+    10601: "targeted_restriction",
+    4089: "targeted_restriction",
+    23206: "procedural_technical",
+    22676: "institutional_rule_of_law",
+    115: "system_dismantling",
+    3951: "consensus_framing",
+    1375: "targeted_restriction",
+    3090: "targeted_restriction",
+    24650: "procedural_technical",
+    1772: "consensus_framing",
+    3678: "system_dismantling",
+    1692: "institutional_rule_of_law",
+    24077: "symbolic_declaratory",
+    349: "institutional_rule_of_law",
+    9769: "targeted_restriction",
+    4656: "symbolic_declaratory",
+    23984: "system_dismantling",
+    2168: "institutional_rule_of_law",
+    4443: "institutional_rule_of_law",
+    4489: "procedural_technical",
+    10290: "targeted_restriction",
+    4071: "targeted_restriction",
+    4088: "targeted_restriction",
+    1507: "system_dismantling",
+    2870: "procedural_technical",
+    1912: "system_dismantling",
+    22658: "symbolic_declaratory",
+    10288: "targeted_restriction",
+    4080: "institutional_rule_of_law",
+    1847: "targeted_restriction",
+    23127: "system_dismantling",
+    4367: "targeted_restriction",
+    9790: "targeted_restriction",
+    4150: "procedural_technical",
+    741: "targeted_restriction",
+    1705: "consensus_framing",
+    1831: "consensus_framing",
+    10600: "targeted_restriction",
+    9767: "targeted_restriction",
+    3830: "system_dismantling",
+    4221: "system_dismantling",
+    3354: "institutional_rule_of_law",
+    9977: "symbolic_declaratory",
+    898: "consensus_framing",
+    24848: "system_dismantling",
+    756: "targeted_restriction",
+    24358: "institutional_rule_of_law",
+    4309: "institutional_rule_of_law",
+    10167: "local_constituency",
+    23633: "procedural_technical",
+    23030: "targeted_restriction",
+    1959: "system_dismantling",
+    23454: "procedural_technical",
+}
+
+# ── prompt templates ─────────────────────────────────────────────────────────
+
+# Original prompt (from mechanism_classification.py — inline subagent)
+# Classifications were done by reading full title + body_text.
+# The second classifier uses a DIFFERENT template:
+#  - English wording (not Dutch)
+#  - Mechanisms presented in DIFFERENT order (reverse alphabetical)
+#  - Asks for RANKING (top 3) instead of single pick
+#  - Includes definition context for each mechanism
+
+MECHANISMS_SHUFLLED = list(reversed(MECHANISMS))
+
+MECHANISM_DEFINITIONS_EN = """1. crisis_response — A temporary, emergency measure responding to an acute event (pandemic, natural disaster, sudden crisis). Reactive and time-limited.
+
+2. system_dismantling — Aims to dismantle, abolish, or fundamentally restructure an existing policy, institution, or regulatory framework. Not reform but abolition/reversal.
+
+3. targeted_restriction — Imposes specific restrictions on a defined group, behavior, or activity. Narrow scope, punitive or exclusionary intent.
+
+4. symbolic_declaratory — Primarily sends a political signal, makes a statement, or takes a position without direct policy impact. Declaratory, symbolic, expressive.
+
+5. procedural_technical — Technical adjustment, budget amendment, implementation detail, or administrative procedure. Bureaucratic, operational, non-ideological.
+
+6. local_constituency — Serves a specific local/regional interest, constituency, or geographic area. NIMBY or local-advocacy pattern.
+
+7. coalition_alignment — Reflects coalition politics: budget compromises, package deals, or alignments between coalition partners. Coalition-maintenance.
+
+8. welfare_service_expansion — Expands government services, social welfare, public goods, or citizen entitlements. Positive provision, not restriction.
+
+9. institutional_rule_of_law — Concerns legal frameworks, rule of law, institutional integrity, judicial process, or constitutional matters. Rule-based, institutional.
+
+10. consensus_framing — Frames the motion as serving a broad, shared interest. Appeals to common ground, national interest, or bipartisan consensus. Inclusive, bridge-building, non-polarizing."""
+
+SECOND_CLASSIFIER_PROMPT = """Classify the following Dutch parliamentary motion according to the mechanism taxonomy below.
+
+MOTION TITLE: {title}
+
+MOTION TEXT: {body}
+
+TASK: Identify the PRIMARY mechanism this motion uses. Select exactly ONE mechanism from the list below. Base your decision on what the motion actually DOES (action-oriented) rather than what it merely TALKS about.
+
+MECHANISM TAXONOMY (read carefully before choosing):
+
+{MECHANISM_DEFINITIONS}
+
+IMPORTANT RULES:
+- Choose the mechanism that BEST describes the dominant pattern of the motion.
+- If a motion could fit multiple mechanisms, pick the most specific one.
+- procedural_technical should be the DEFAULT only if no other mechanism fits better.
+- Return ONLY the mechanism key exactly as listed above (e.g., "system_dismantling").
+
+Respond with a JSON object containing:
+- "mechanism": the selected mechanism key
+- "confidence": 1-5 (1=very uncertain, 5=very certain)
+- "reasoning": brief explanation (max 2 sentences)"""
+
+
+def build_second_classifier_prompt(title: str, body_text: str) -> str:
+    text = body_text or title or ""
+    if len(text) > 1200:
+        text = text[:1200] + "..."
+    return SECOND_CLASSIFIER_PROMPT.format(
+        title=title or "", body=text, MECHANISM_DEFINITIONS=MECHANISM_DEFINITIONS_EN
+    )
+
+
+# ── LLM call helpers ─────────────────────────────────────────────────────────
+
+
+def chat_completion_json(
+    messages: list[dict[str, str]],
+    model: str | None = None,
+    retries: int = 3,
+) -> dict[str, Any] | None:
+    """Call chat_completion and parse JSON response with retries."""
+    model = model or config.QWEN_MODEL
+    prompt = messages[0]["content"]
+    system_msg = (
+        "You are a political science classifier. You classify Dutch parliamentary "
+        "motions by their dominant mechanism type. Respond ONLY with valid JSON. "
+        "No markdown, no code fences, no preamble — pure JSON object."
+    )
+    full_messages = [
+        {"role": "system", "content": system_msg},
+        {"role": "user", "content": prompt},
+    ]
+
+    backoff = 0.5
+    for attempt in range(1, retries + 1):
+        try:
+            raw = chat_completion(full_messages, model=model)
+        except ProviderError as exc:
+            if attempt == retries:
+                logger.error("ProviderError on attempt %d: %s", attempt, exc)
+                return None
+            time.sleep(backoff * (2 ** (attempt - 1)))
+            continue
+
+        raw = raw.strip()
+        if raw.startswith("```"):
+            raw = raw.split("```", 2)[1]
+            if raw.startswith("json"):
+                raw = raw[4:]
+            raw = raw.strip()
+
+        try:
+            result = json.loads(raw)
+            if "mechanism" in result and result["mechanism"] in MECHANISMS:
+                return result
+            logger.warning(
+                "Invalid mechanism '%s' on attempt %d", result.get("mechanism"), attempt
+            )
+        except json.JSONDecodeError:
+            logger.warning("JSON decode failed on attempt %d: %s", attempt, raw[:100])
+
+        if attempt < retries:
+            time.sleep(backoff * (2 ** (attempt - 1)))
+
+    return None
+
+
+def chat_completion_json_parallel(
+    message_batches: list[list[dict[str, str]]],
+    model: str | None = None,
+    max_workers: int = 5,
+) -> list[dict[str, Any] | None]:
+    """
+    Run multiple chat completions in parallel using ThreadPoolExecutor.
+
+    Each element in message_batches is a list of messages for one completion.
+    Returns a list of parsed JSON dicts (or None for failures), same order.
+    """
+    model = model or config.QWEN_MODEL
+
+    def _fetch_one(messages: list[dict[str, str]]) -> dict[str, Any] | None:
+        return chat_completion_json(messages, model=model)
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = [executor.submit(_fetch_one, batch) for batch in message_batches]
+        return [f.result() for f in futures]
+
+
+# ── data loading ─────────────────────────────────────────────────────────────
+
+
+def load_motions(db_path: str, motion_ids: list[int]) -> list[dict[str, Any]]:
+    """Load motion data from the database for the given motion IDs."""
+    con = duckdb.connect(db_path)
+    try:
+        placeholders = ",".join("?" for _ in motion_ids)
+        rows = con.execute(
+            f"""
+            SELECT r.motion_id, m.title, m.body_text, r.year, r.centrist_support_strict
+            FROM right_wing_motions r
+            JOIN motions m ON r.motion_id = m.id
+            WHERE r.motion_id IN ({placeholders})
+            ORDER BY r.motion_id
+            """,
+            motion_ids,
+        ).fetchall()
+
+        return [
+            {
+                "motion_id": r[0],
+                "title": r[1] or "",
+                "body_text": r[2] or "",
+                "year": r[3],
+                "centrist_support_strict": r[4],
+            }
+            for r in rows
+        ]
+    finally:
+        con.close()
+
+
+# ── classification ───────────────────────────────────────────────────────────
+
+
+def classify_motions_second_pass(
+    motions: list[dict[str, Any]],
+    second_model: str | None = None,
+    batch_size: int = 10,
+    max_workers: int = 5,
+) -> dict[int, dict[str, Any]]:
+    """Run second classifier on all motions, return motion_id -> result dict."""
+    second_model = second_model or config.QWEN_MODEL
+    results: dict[int, dict[str, Any]] = {}
+
+    for i in range(0, len(motions), batch_size):
+        batch = motions[i : i + batch_size]
+        logger.info(
+            "Batch %d/%d (%d motions)",
+            i // batch_size + 1,
+            (len(motions) - 1) // batch_size + 1,
+            len(batch),
+        )
+
+        message_batches = []
+        for m in batch:
+            prompt = build_second_classifier_prompt(m["title"], m["body_text"])
+            message_batches.append([{"role": "user", "content": prompt}])
+
+        raw_results = chat_completion_json_parallel(
+            message_batches, model=second_model, max_workers=max_workers
+        )
+
+        for m, res in zip(batch, raw_results):
+            mid = m["motion_id"]
+            if res and res.get("mechanism") in MECHANISMS:
+                results[mid] = {
+                    "mechanism": res["mechanism"],
+                    "confidence": res.get("confidence", 0),
+                    "reasoning": res.get("reasoning", ""),
+                    "error": None,
+                }
+            else:
+                results[mid] = {
+                    "mechanism": None,
+                    "confidence": 0,
+                    "reasoning": "",
+                    "error": "classification failed",
+                }
+
+        time.sleep(0.5)
+
+    return results
+
+
+# ── agreement analysis ───────────────────────────────────────────────────────
+
+
+def compute_cohens_kappa(
+    rater1: dict[int, str],
+    rater2: dict[int, str],
+    categories: list[str],
+) -> dict[str, Any]:
+    """Compute Cohen's kappa for two raters.
+
+    Uses only motion_ids present in BOTH raters.
+    """
+    common_ids = sorted(set(rater1) & set(rater2))
+
+    n = len(common_ids)
+    if n == 0:
+        return {"kappa": None, "agreement_rate": None, "n": 0, "error": "no common motions"}
+
+    agreements = 0
+    for mid in common_ids:
+        if rater1[mid] == rater2[mid]:
+            agreements += 1
+
+    p_o = agreements / n
+
+    # Expected agreement
+    p_e = 0.0
+    for cat in categories:
+        p1 = sum(1 for mid in common_ids if rater1[mid] == cat) / n
+        p2 = sum(1 for mid in common_ids if rater2[mid] == cat) / n
+        p_e += p1 * p2
+
+    if p_e >= 1.0:
+        kappa = 1.0
+    else:
+        kappa = (p_o - p_e) / (1.0 - p_e) if p_e < 1.0 else 0.0
+
+    return {
+        "kappa": round(kappa, 4),
+        "agreement_rate": round(p_o, 4),
+        "n": n,
+        "agreements": agreements,
+        "p_o": round(p_o, 4),
+        "p_e": round(p_e, 4),
+        "error": None,
+    }
+
+
+def find_disagreements(
+    rater1: dict[int, str],
+    rater2: dict[int, str],
+) -> list[dict[str, Any]]:
+    """Find all disagreements between two raters."""
+    common_ids = sorted(set(rater1) & set(rater2))
+    disagreements = []
+    for mid in common_ids:
+        c1 = rater1[mid]
+        c2 = rater2[mid]
+        if c1 != c2:
+            disagreements.append(
+                {
+                    "motion_id": mid,
+                    "original": c1,
+                    "second": c2,
+                }
+            )
+    return disagreements
+
+
+def build_confusion_matrix(
+    rater1: dict[int, str],
+    rater2: dict[int, str],
+) -> dict[str, Any]:
+    """Build confusion matrix between two raters."""
+    common_ids = set(rater1) & set(rater2)
+    matrix: dict[str, Counter[str]] = {m: Counter() for m in MECHANISMS}
+    for mid in common_ids:
+        c1 = rater1[mid]
+        c2 = rater2[mid]
+        matrix[c1][c2] += 1
+    return {k: dict(v) for k, v in matrix.items()}
+
+
+# ── resolution ───────────────────────────────────────────────────────────────
+
+
+def resolve_disagreements(
+    disagreements: list[dict[str, Any]],
+    second_results: dict[int, dict[str, Any]],
+    motions: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Resolve disagreements by preferring higher-confidence classification."""
+    motion_map = {m["motion_id"]: m for m in motions}
+    resolved = []
+    for d in disagreements:
+        mid = d["motion_id"]
+        sr = second_results.get(mid, {})
+        confidence = sr.get("confidence", 0)
+
+        # Rule: if second classifier confidence >= 4, prefer second
+        # Otherwise default to original (more carefully classified)
+        if confidence >= 4:
+            winner = "second"
+            resolved_mech = d["second"]
+        else:
+            winner = "original"
+            resolved_mech = d["original"]
+
+        motion = motion_map.get(mid, {})
+        resolved.append(
+            {
+                "motion_id": mid,
+                "title": motion.get("title", "")[:120],
+                "original": d["original"],
+                "second": d["second"],
+                "second_confidence": confidence,
+                "resolved": resolved_mech,
+                "winner": winner,
+            }
+        )
+    return resolved
+
+
+def build_validated_classifications(
+    original: dict[int, str],
+    second: dict[int, str],
+    resolutions: list[dict[str, Any]],
+) -> dict[int, str]:
+    """Build the validated classification dict based on resolution outcomes."""
+    resolution_map = {r["motion_id"]: r["resolved"] for r in resolutions}
+    validated = dict(original)
+    for mid in validated:
+        if mid in resolution_map:
+            validated[mid] = resolution_map[mid]
+    return validated
+
+
+# ── report generation ────────────────────────────────────────────────────────
+
+
+def generate_report(
+    kappa_result: dict[str, Any],
+    disagreements: list[dict[str, Any]],
+    resolutions: list[dict[str, Any]],
+    confusion: dict[str, Any],
+    validated_dist: dict[str, Any],
+    second_results: dict[int, dict[str, Any]],
+    output_path: str,
+) -> None:
+    """Generate mechanism validation markdown report."""
+    n_second_classified = sum(1 for v in second_results.values() if v.get("mechanism"))
+    avg_confidence = (
+        sum(v.get("confidence", 0) for v in second_results.values() if v.get("mechanism"))
+        / max(n_second_classified, 1)
+    )
+
+    lines = [
+        "# Mechanism Classification Validation Report",
+        "",
+        "## 1. Inter-Rater Reliability",
+        "",
+        f"- **Motions compared:** {kappa_result['n']}",
+        f"- **Agreements:** {kappa_result['agreements']} / {kappa_result['n']}",
+        f"- **Agreement rate:** {kappa_result['agreement_rate']:.1%}",
+        f"- **Cohen's kappa (κ):** {kappa_result['kappa']}",
+        f"  - P_o (observed): {kappa_result['p_o']:.4f}",
+        f"  - P_e (expected): {kappa_result['p_e']:.4f}",
+        "",
+    ]
+
+    kappa = kappa_result["kappa"]
+    if kappa is not None:
+        if kappa < 0.0:
+            strength = "Less than chance agreement"
+        elif kappa < 0.20:
+            strength = "Slight agreement"
+        elif kappa < 0.40:
+            strength = "Fair agreement"
+        elif kappa < 0.60:
+            strength = "Moderate agreement"
+        elif kappa < 0.80:
+            strength = "Substantial agreement"
+        else:
+            strength = "Almost perfect agreement"
+        lines.append(f"**Interpretation:** {strength}")
+        lines.append("")
+
+    if kappa is not None and kappa < 0.60:
+        lines.append("**The mechanism taxonomy needs revision.** The inter-rater agreement is below 0.6, suggesting the 10-mechanism framework is not being applied consistently across raters. Consider:")
+        lines.append("- Simplifying or merging ambiguous mechanism pairs")
+        lines.append("- Adding clearer decision rules for borderline cases")
+        lines.append("- Reducing the number of mechanisms")
+        lines.append("")
+    elif kappa is not None:
+        lines.append("**The mechanism taxonomy appears adequate.** Inter-rater agreement is at or above 0.6, indicating reasonable consistency.")
+        lines.append("")
+
+    lines.extend([
+        "## 2. Second Classifier Summary",
+        "",
+        f"- **Model:** {config.QWEN_MODEL}",
+        f"- **Motions classified:** {n_second_classified}",
+        f"- **Average confidence:** {avg_confidence:.1f}/5",
+        "",
+    ])
+
+    conf_dist = Counter()
+    for v in second_results.values():
+        conf_dist[v.get("confidence", 0)] += 1
+    lines.append("### Confidence Distribution")
+    lines.append("| Confidence | Count |")
+    lines.append("|------------|-------|")
+    for level in range(1, 6):
+        lines.append(f"| {level} | {conf_dist.get(level, 0)} |")
+    lines.append("")
+
+    lines.extend([
+        "## 3. Disagreement Table",
+        "",
+        f"**Total disagreements:** {len(disagreements)} / {kappa_result['n']} ({len(disagreements) / max(kappa_result['n'], 1) * 100:.1f}%)",
+        "",
+        "| Motion ID | Title | Original | Second | Confidence | Resolved | Winner |",
+        "|-----------|-------|----------|--------|------------|----------|--------|",
+    ])
+
+    for r in resolutions:
+        orig_label = MECHANISM_LABELS_NL.get(r["original"], r["original"])
+        second_label = MECHANISM_LABELS_NL.get(r["second"], r["second"])
+        res_label = MECHANISM_LABELS_NL.get(r["resolved"], r["resolved"])
+        lines.append(
+            f"| {r['motion_id']} | {r['title'][:80]} | {orig_label} | {second_label} | {r['second_confidence']} | {res_label} | {r['winner']} |"
+        )
+
+    lines.extend([
+        "",
+        "## 4. Mechanism Distribution Comparison",
+        "",
+        "| Mechanism | Original Count | Second Count | Validated Count |",
+        "|-----------|---------------|--------------|-----------------|",
+    ])
+
+    orig_dist = Counter(ORIGINAL_CLASSIFICATIONS.values())
+    second_dist = Counter()
+    for v in second_results.values():
+        m = v.get("mechanism")
+        if m:
+            second_dist[m] += 1
+
+    for mech in MECHANISMS:
+        label = MECHANISM_LABELS_NL.get(mech, mech)
+        o_cnt = orig_dist.get(mech, 0)
+        s_cnt = second_dist.get(mech, 0)
+        v_cnt = validated_dist.get(mech, 0)
+        lines.append(f"| {label} | {o_cnt} | {s_cnt} | {v_cnt} |")
+
+    lines.extend([
+        "",
+        "## 5. Confusion Matrix (Top Rows)",
+        "",
+        "| Original \\ Second | " + " | ".join(MECHANISM_LABELS_EN[m][:20] for m in MECHANISMS) + " |",
+        "|" + "---|" * (len(MECHANISMS) + 1),
+    ])
+
+    for mech in MECHANISMS:
+        label = MECHANISM_LABELS_EN[mech][:20]
+        row_data = confusion.get(mech, {})
+        cells = [str(row_data.get(m, 0)) for m in MECHANISMS]
+        lines.append(f"| {label} | {' | '.join(cells)} |")
+
+    lines.extend([
+        "",
+        "## 6. Conclusion",
+        "",
+        f"Cohen's kappa of **{kappa}** indicates **{strength.lower()}** between the original inline classification and the independent second classifier.",
+        "",
+        "### Key findings:",
+        f"- {kappa_result['agreements']} out of {kappa_result['n']} motions agreed ({kappa_result['agreement_rate']:.1%})",
+        f"- {len(disagreements)} disagreements resolved: {sum(1 for r in resolutions if r['winner'] == 'original')} kept original, {sum(1 for r in resolutions if r['winner'] == 'second')} adopted second",
+        "",
+    ])
+
+    top_disagreement_pairs = Counter()
+    for d in disagreements:
+        pair = f"{d['original']} / {d['second']}"
+        top_disagreement_pairs[pair] += 1
+
+    if top_disagreement_pairs:
+        lines.append("### Most common disagreement pairs:")
+        for pair, cnt in top_disagreement_pairs.most_common(5):
+            lines.append(f"- {pair}: {cnt} times")
+        lines.append("")
+
+    lines.append("### Revised mechanism taxonomy recommendation:")
+    if kappa is not None and kappa < 0.60:
+        lines.append("- Taxonomy needs revision to improve inter-rater reliability.")
+        if top_disagreement_pairs:
+            top_pair = top_disagreement_pairs.most_common(1)[0][0]
+            lines.append(f"- Most confused pair: {top_pair} — consider merging or clarifying distinction.")
+    else:
+        lines.append("- Taxonomy is sufficiently reliable. Minor clarifications may be helpful for borderline cases.")
+    lines.append("")
+
+    out_path = Path(output_path)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    logger.info("Report written to %s", out_path)
+
+
+# ── main ─────────────────────────────────────────────────────────────────────
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Validate mechanism classification with second classifier"
+    )
+    parser.add_argument("--db", default="data/motions.db", help="Path to DuckDB database")
+    parser.add_argument(
+        "--model",
+        default=None,
+        help=f"Second classifier model (default: {config.QWEN_MODEL})",
+    )
+    parser.add_argument("--batch-size", type=int, default=10, help="Motions per batch")
+    parser.add_argument("--max-workers", type=int, default=3, help="Max parallel workers")
+    parser.add_argument(
+        "--output",
+        default="reports/overton_window/mechanism_validation.md",
+        help="Output report path",
+    )
+    parser.add_argument(
+        "--save-results",
+        default=None,
+        help="Save full second classification results to JSON path",
+    )
+    args = parser.parse_args()
+
+    second_model = args.model or config.QWEN_MODEL
+    logger.info("Second classifier model: %s", second_model)
+
+    motion_ids = list(ORIGINAL_CLASSIFICATIONS.keys())
+    logger.info("Loading %d motions from database...", len(motion_ids))
+
+    motions = load_motions(args.db, motion_ids)
+    logger.info("Loaded %d motions", len(motions))
+
+    logger.info("Running second classifier...")
+    second_results = classify_motions_second_pass(
+        motions,
+        second_model=second_model,
+        batch_size=args.batch_size,
+        max_workers=args.max_workers,
+    )
+
+    # Extract mechanism-only dict for agreement analysis
+    second_classifications: dict[int, str] = {}
+    for mid, res in second_results.items():
+        if res.get("mechanism") and res["mechanism"] in MECHANISMS:
+            second_classifications[mid] = res["mechanism"]
+
+    n_second_classified = len(second_classifications)
+    logger.info(
+        "Second classifier completed: %d/%d motions classified",
+        n_second_classified,
+        len(motions),
+    )
+
+    # Filter original to only include motions with second classification
+    original_filtered = {
+        mid: ORIGINAL_CLASSIFICATIONS[mid]
+        for mid in second_classifications
+        if mid in ORIGINAL_CLASSIFICATIONS
+    }
+
+    # Compute Cohen's kappa
+    kappa_result = compute_cohens_kappa(
+        original_filtered, second_classifications, MECHANISMS
+    )
+    logger.info("Cohen's kappa: %s", kappa_result["kappa"])
+    logger.info("Agreement rate: %s", kappa_result["agreement_rate"])
+
+    # Find disagreements
+    disagreements = find_disagreements(original_filtered, second_classifications)
+    logger.info("Disagreements: %d", len(disagreements))
+
+    # Build confusion matrix
+    confusion = build_confusion_matrix(original_filtered, second_classifications)
+
+    # Resolve disagreements
+    resolutions = resolve_disagreements(disagreements, second_results, motions)
+
+    # Build validated classifications
+    validated = build_validated_classifications(
+        ORIGINAL_CLASSIFICATIONS, second_classifications, resolutions
+    )
+    validated_dist = Counter(validated.values())
+
+    # Save results if requested
+    if args.save_results:
+        save_path = Path(args.save_results)
+        save_path.parent.mkdir(parents=True, exist_ok=True)
+        save_data = {
+            "kappa": kappa_result["kappa"],
+            "agreement_rate": kappa_result["agreement_rate"],
+            "n_motions": kappa_result["n"],
+            "n_disagreements": len(disagreements),
+            "second_results": {
+                str(mid): res for mid, res in second_results.items()
+            },
+            "resolutions": resolutions,
+        }
+        save_path.write_text(json.dumps(save_data, indent=2, ensure_ascii=False), encoding="utf-8")
+        logger.info("Results saved to %s", save_path)
+
+    # Generate report
+    generate_report(
+        kappa_result=kappa_result,
+        disagreements=disagreements,
+        resolutions=resolutions,
+        confusion=confusion,
+        validated_dist=dict(validated_dist),
+        second_results=second_results,
+        output_path=args.output,
+    )
+
+    print(f"\nCohen's kappa: {kappa_result['kappa']}")
+    print(f"Agreement rate: {kappa_result['agreement_rate']:.1%}")
+    print(f"Disagreements: {len(disagreements)}/{kappa_result['n']}")
+    print(f"Report: {args.output}")
+
+    if kappa_result["kappa"] is not None:
+        if kappa_result["kappa"] < 0.60:
+            print("TAXONOMY NEEDS REVISION: kappa < 0.6 indicates poor reliability")
+        else:
+            print("TAXONOMY ADEQUATE: kappa >= 0.6 indicates acceptable reliability")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/migrate_mp_level_metrics.py

@@ -0,0 +1,109 @@
+"""Add MP-weighted support columns to right_wing_motions.
+
+Adds centrist_support_mp, centrist_support_strict, center_right_support,
+and left_support_mp — all computed as the fraction of individual MPs
+within each party set who voted 'voor'.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from analysis.right_wing.common import ROOT
+
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import duckdb
+
+from analysis.config import CANONICAL_LEFT
+from analysis.right_wing.common import CANONICAL_CENTRIST, CANONICAL_CENTRIST_STRICT
+
+CANONICAL_CENTER_RIGHT = frozenset({"VVD", "BBB"})
+
+COLUMNS = [
+    ("centrist_support_mp", CANONICAL_CENTRIST),
+    ("centrist_support_strict", CANONICAL_CENTRIST_STRICT),
+    ("center_right_support", CANONICAL_CENTER_RIGHT),
+    ("left_support_mp", CANONICAL_LEFT),
+]
+
+
+def compute_mp_support(
+    votes: dict[str, dict[str, int]], parties: frozenset[str]
+) -> float | None:
+    total_voor = 0
+    total_cast = 0
+    for party, pv in votes.items():
+        if party not in parties:
+            continue
+        voor = pv.get("voor", 0)
+        tegen = pv.get("tegen", 0)
+        tv = voor + tegen
+        if tv == 0:
+            continue
+        total_voor += voor
+        total_cast += tv
+    if total_cast == 0:
+        return None
+    return total_voor / total_cast
+
+
+def main(db_path: str = "data/motions.db"):
+    db = Path(db_path)
+    con = duckdb.connect(str(db))
+
+    votemap: dict[int, dict[str, dict[str, int]]] = {}
+    vote_rows = con.execute(
+        """
+        SELECT motion_id, party, vote, COUNT(*) as n
+        FROM mp_votes
+        WHERE party IS NOT NULL
+        GROUP BY motion_id, party, vote
+        """
+    ).fetchall()
+
+    for motion_id, party, vote, n in vote_rows:
+        mv = votemap.setdefault(motion_id, {})
+        pv = mv.setdefault(party, {"voor": 0, "tegen": 0, "afwezig": 0})
+        pv[vote] = pv.get(vote, 0) + n
+
+    # Add columns if missing
+    for col_name, _party_set in COLUMNS:
+        col_check = con.execute(
+            "SELECT column_name FROM information_schema.columns "
+            "WHERE table_name = 'right_wing_motions' AND column_name = ?",
+            [col_name],
+        ).fetchone()
+        if col_check is None:
+            con.execute(
+                f"ALTER TABLE right_wing_motions ADD COLUMN {col_name} DOUBLE"
+            )
+            print(f"Added {col_name} column")
+
+    # Update rows
+    rows = con.execute(
+        "SELECT motion_id FROM right_wing_motions"
+    ).fetchall()
+
+    updated = 0
+    skipped = 0
+    for (motion_id,) in rows:
+        votes = votemap.get(motion_id)
+        if votes is None:
+            skipped += 1
+            continue
+        for col_name, party_set in COLUMNS:
+            val = compute_mp_support(votes, party_set)
+            con.execute(
+                f"UPDATE right_wing_motions SET {col_name} = ? WHERE motion_id = ?",
+                [val, motion_id],
+            )
+        updated += 1
+
+    con.close()
+    print(f"Updated {updated} rows, skipped {skipped}")
+
+
+if __name__ == "__main__":
+    main()

analysis/right_wing/overton_svd_drift.py

@@ -0,0 +1,547 @@
+#!/usr/bin/env python3
+"""Quantify Overton window shift via Procrustes-aligned center drift.
+
+Uses Procrustes-aligned, PCA-rotated 2D party positions from
+load_party_scores_all_windows_aligned() to measure rightward drift
+of the centrist center of gravity on a common reference frame.
+Axes are aligned across all windows — no stability validation needed.
+
+Usage:
+    uv run python analysis/right_wing/overton_svd_drift.py
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, List
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+
+matplotlib.use("Agg")
+
+from analysis.right_wing.common import ROOT, DB_PATH, REPORTS_DIR
+
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from analysis.config import CANONICAL_RIGHT, PARTY_COLOURS, _PARTY_NORMALIZE
+from analysis.explorer_data import (
+    get_uniform_dim_windows,
+    load_party_scores_all_windows_aligned,
+)
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger("overton_svd_drift")
+
+CANONICAL_CENTRIST = frozenset(
+    {"VVD", "D66", "CDA", "NSC", "BBB", "CU", "ChristenUnie"}
+)
+
+
+def _normalize_party(raw: str) -> str:
+    """Normalize a raw party name to its canonical abbreviation."""
+    return _PARTY_NORMALIZE.get(raw, raw)
+
+
+def _party_in_set(party: str, canonical_set: frozenset) -> bool:
+    """Check party membership against a canonical set.
+
+    Checks the raw party name and its normalized form so that both
+    'CU' and 'ChristenUnie' match a set containing either variant.
+    """
+    if party in canonical_set:
+        return True
+    normalized = _normalize_party(party)
+    return normalized != party and normalized in canonical_set
+
+
+def _fmt_axis(val: float | None) -> str:
+    return f"{val:.4f}" if val is not None else "N/A"
+
+
+def compute_aligned_centers(
+    scores: Dict[str, List[List[float]]],
+    windows: List[str],
+    annual_indices: List[int],
+) -> List[Dict[str, Any]]:
+    """Compute centrist and right-wing centers of gravity per window.
+
+    Uses Procrustes-aligned party positions from
+    load_party_scores_all_windows_aligned().  Missing parties in a
+    window are simply skipped (mean over available parties).
+    """
+    results: List[Dict[str, Any]] = []
+
+    for idx, window_id in enumerate(windows):
+        centrist_a1: List[float] = []
+        centrist_a2: List[float] = []
+        right_a1: List[float] = []
+        right_a2: List[float] = []
+        centrist_present: List[str] = []
+        right_present: List[str] = []
+
+        for party, window_scores in scores.items():
+            if idx >= len(window_scores):
+                continue
+            a1, a2 = window_scores[idx]
+
+            if _party_in_set(party, CANONICAL_CENTRIST):
+                centrist_a1.append(a1)
+                centrist_a2.append(a2)
+                centrist_present.append(party)
+            if _party_in_set(party, CANONICAL_RIGHT):
+                right_a1.append(a1)
+                right_a2.append(a2)
+                right_present.append(party)
+
+        results.append(
+            {
+                "window_id": window_id,
+                "centrist_mean_axis1": float(np.mean(centrist_a1)) if centrist_a1 else None,
+                "centrist_mean_axis2": float(np.mean(centrist_a2)) if centrist_a2 else None,
+                "right_mean_axis1": float(np.mean(right_a1)) if right_a1 else None,
+                "right_mean_axis2": float(np.mean(right_a2)) if right_a2 else None,
+                "centrist_parties_present": sorted(centrist_present),
+                "right_parties_present": sorted(right_present),
+                "centrist_count": len(centrist_present),
+                "right_count": len(right_present),
+                "is_annual": idx in annual_indices,
+            }
+        )
+
+    return results
+
+
+def compute_drift_metrics(
+    annual_centers: List[Dict[str, Any]],
+) -> Dict[str, Any]:
+    """Compute drift metrics for annual windows only.
+
+    Returns:
+        euclidean_steps: year-over-year displacements
+        net_displacement: first-to-last Euclidean distance
+        angular_direction_deg: arctan2(dy, dx) in degrees
+        approach_to_right: whether centrist center is moving toward
+            or away from the right-wing center
+        right_net: net displacement of right-wing center for comparison
+    """
+    valid = [c for c in annual_centers if c["centrist_mean_axis1"] is not None]
+
+    if len(valid) < 2:
+        return {
+            "euclidean_steps": [],
+            "net_displacement": None,
+            "net_dx": None,
+            "net_dy": None,
+            "angular_direction_deg": None,
+            "approach_to_right": None,
+            "right_net": None,
+        }
+
+    euclidean_steps = []
+    for i in range(len(valid) - 1):
+        dx = (
+            valid[i + 1]["centrist_mean_axis1"]
+            - valid[i]["centrist_mean_axis1"]
+        )
+        dy = (
+            valid[i + 1]["centrist_mean_axis2"]
+            - valid[i]["centrist_mean_axis2"]
+        )
+        dist = float(np.sqrt(dx**2 + dy**2))
+        euclidean_steps.append(
+            {
+                "window_pair": f"{valid[i]['window_id']}-{valid[i+1]['window_id']}",
+                "distance": round(dist, 6),
+                "dx": round(dx, 6),
+                "dy": round(dy, 6),
+            }
+        )
+
+    first = valid[0]
+    last = valid[-1]
+    dx_net = last["centrist_mean_axis1"] - first["centrist_mean_axis1"]
+    dy_net = last["centrist_mean_axis2"] - first["centrist_mean_axis2"]
+    net_disp = float(np.sqrt(dx_net**2 + dy_net**2))
+    angle_rad = np.arctan2(dy_net, dx_net)
+    angle_deg = float(np.degrees(angle_rad))
+
+    right_net = None
+    right_valid = [
+        c for c in annual_centers if c["right_mean_axis1"] is not None
+    ]
+    if len(right_valid) >= 2:
+        r_first = right_valid[0]
+        r_last = right_valid[-1]
+        r_dx = r_last["right_mean_axis1"] - r_first["right_mean_axis1"]
+        r_dy = r_last["right_mean_axis2"] - r_first["right_mean_axis2"]
+        right_net = {
+            "net_displacement": round(float(np.sqrt(r_dx**2 + r_dy**2)), 6),
+            "net_dx": round(r_dx, 6),
+            "net_dy": round(r_dy, 6),
+        }
+
+    approach_to_right = None
+    if (
+        first.get("right_mean_axis1") is not None
+        and last.get("right_mean_axis1") is not None
+    ):
+        first_dist = float(
+            np.sqrt(
+                (first["centrist_mean_axis1"] - first["right_mean_axis1"]) ** 2
+                + (first["centrist_mean_axis2"] - first["right_mean_axis2"]) ** 2
+            )
+        )
+        last_dist = float(
+            np.sqrt(
+                (last["centrist_mean_axis1"] - last["right_mean_axis1"]) ** 2
+                + (last["centrist_mean_axis2"] - last["right_mean_axis2"]) ** 2
+            )
+        )
+        delta = last_dist - first_dist
+        if abs(delta) < 1e-9:
+            direction = "unchanged"
+        elif delta < 0:
+            direction = "toward right"
+        else:
+            direction = "away from right"
+        approach_to_right = {
+            "first_distance": round(first_dist, 6),
+            "last_distance": round(last_dist, 6),
+            "delta_distance": round(delta, 6),
+            "direction": direction,
+        }
+
+    return {
+        "euclidean_steps": euclidean_steps,
+        "net_displacement": round(net_disp, 6),
+        "net_dx": round(dx_net, 6),
+        "net_dy": round(dy_net, 6),
+        "angular_direction_deg": round(angle_deg, 2),
+        "approach_to_right": approach_to_right,
+        "right_net": right_net,
+    }
+
+
+def plot_trajectory(
+    annual_centers: List[Dict[str, Any]],
+    output_path: str,
+) -> None:
+    """Plot centrist center trajectory with right-wing reference on 2D compass.
+
+    Uses arrows between consecutive annual windows and year labels.
+    """
+    fig, ax = plt.subplots(figsize=(10, 8))
+
+    cent_a1 = [c["centrist_mean_axis1"] for c in annual_centers]
+    cent_a2 = [c["centrist_mean_axis2"] for c in annual_centers]
+    windows_labels = [
+        c["window_id"]
+        for c in annual_centers
+        if c["centrist_mean_axis1"] is not None
+    ]
+    cent_a1_valid = [v for v in cent_a1 if v is not None]
+    cent_a2_valid = [v for v in cent_a2 if v is not None]
+
+    if len(cent_a1_valid) < 2:
+        ax.text(
+            0.5,
+            0.5,
+            "Insufficient data for trajectory plot",
+            transform=ax.transAxes,
+            ha="center",
+            va="center",
+        )
+        fig.savefig(output_path, dpi=150, bbox_inches="tight", facecolor="white")
+        plt.close(fig)
+        return
+
+    for i in range(len(cent_a1_valid) - 1):
+        ax.annotate(
+            "",
+            xy=(cent_a1_valid[i + 1], cent_a2_valid[i + 1]),
+            xytext=(cent_a1_valid[i], cent_a2_valid[i]),
+            arrowprops=dict(arrowstyle="->", color="#1E73BE", lw=1.5, alpha=0.6),
+        )
+
+    ax.plot(
+        cent_a1_valid,
+        cent_a2_valid,
+        "o-",
+        color="#1E73BE",
+        linewidth=2,
+        markersize=8,
+        label="Centrist center (VVD, D66, CDA, NSC, BBB, CU)",
+        zorder=3,
+    )
+
+    # Right-wing trajectory (dashed reference)
+    right_a1 = [c["right_mean_axis1"] for c in annual_centers]
+    right_a2 = [c["right_mean_axis2"] for c in annual_centers]
+    right_a1_valid = [v for v in right_a1 if v is not None]
+    right_a2_valid = [v for v in right_a2 if v is not None]
+
+    if right_a1_valid and right_a2_valid:
+        ax.plot(
+            right_a1_valid,
+            right_a2_valid,
+            "s--",
+            color="#6A1B9A",
+            linewidth=1.5,
+            markersize=6,
+            label="Right-wing center (PVV, FVD, JA21, SGP)",
+            alpha=0.7,
+            zorder=2,
+        )
+
+    # Year labels
+    for i, label in enumerate(windows_labels):
+        if i < len(cent_a1_valid):
+            ax.annotate(
+                str(label),
+                (cent_a1_valid[i], cent_a2_valid[i]),
+                textcoords="offset points",
+                xytext=(7, 7),
+                fontsize=8,
+                color="#333333",
+            )
+
+    ax.axhline(0, color="#CCCCCC", linewidth=0.5, linestyle="-")
+    ax.axvline(0, color="#CCCCCC", linewidth=0.5, linestyle="-")
+
+    ax.set_xlabel("PCA Axis 1 (Procrustes-aligned)")
+    ax.set_ylabel("PCA Axis 2 (Procrustes-aligned)")
+    ax.set_title(
+        "Parliamentary Center Trajectory (Procrustes-Aligned PCA)",
+        fontsize=11,
+    )
+    ax.legend(loc="upper left", fontsize=8, framealpha=0.9)
+    ax.set_aspect("equal", adjustable="datalim")
+    ax.grid(True, alpha=0.3)
+
+    fig.tight_layout()
+    fig.savefig(output_path, dpi=150, bbox_inches="tight", facecolor="white")
+    plt.close(fig)
+    logger.info("Chart saved to %s", output_path)
+
+
+def write_report(
+    centers: List[Dict[str, Any]],
+    annual_centers: List[Dict[str, Any]],
+    drift: Dict[str, Any],
+    output_path: str,
+    chart_path: str,
+    non_annual: List[str],
+) -> None:
+    """Write the center drift report as Markdown."""
+    lines: List[str] = []
+
+    lines.append("# Center Drift Report (Procrustes-Aligned)\n")
+
+    lines.append("## Alignment Method\n")
+    lines.append(
+        "Party positions are Procrustes-aligned across all windows, then "
+        "PCA-rotated to a common 2D reference frame. This ensures that axis "
+        "orientation is consistent across time — no stability validation is "
+        "needed because all positions live in the same coordinate system.\n"
+    )
+    lines.append(
+        "This is the same alignment used by the Explorer UI compass and "
+        "trajectories: 1) zero-padding vectors to max dimension across all "
+        "windows, 2) chained Procrustes orthogonal rotation (each window to "
+        "the previous aligned one), 3) global PCA on the stacked aligned "
+        "matrix, 4) flip-correction per component using canonical left/right "
+        "parties.\n"
+    )
+
+    if non_annual:
+        lines.append(
+            f"**Note:** Non-annual windows excluded from drift analysis: "
+            f"{', '.join(sorted(non_annual))}\n"
+        )
+
+    lines.append("## Centrist Center of Gravity\n")
+    lines.append(
+        "| Window | Centrist Ax1 | Centrist Ax2 | Right Ax1 | Right Ax2 | "
+        "Centrist Parties | Right Parties |"
+    )
+    lines.append("|---|---|---|---|---|---|---|")
+    for c in centers:
+        cent_a1 = _fmt_axis(c["centrist_mean_axis1"])
+        cent_a2 = _fmt_axis(c["centrist_mean_axis2"])
+        right_a1 = _fmt_axis(c["right_mean_axis1"])
+        right_a2 = _fmt_axis(c["right_mean_axis2"])
+        cent_parties = ", ".join(c["centrist_parties_present"])
+        right_parties = ", ".join(c["right_parties_present"])
+        lines.append(
+            f"| {c['window_id']} | {cent_a1} | {cent_a2} | "
+            f"{right_a1} | {right_a2} | {cent_parties} | {right_parties} |"
+        )
+
+    lines.append("")
+
+    lines.append("## Drift Metrics (Annual Windows Only)\n")
+
+    if drift.get("net_displacement") is not None:
+        lines.append(
+            f"- **Net centrist displacement (first → last):** "
+            f"{drift['net_displacement']}"
+        )
+        lines.append(f"  - Δ axis-1: {drift['net_dx']}")
+        lines.append(f"  - Δ axis-2: {drift['net_dy']}")
+        lines.append(
+            f"- **Net direction:** {drift['angular_direction_deg']}° "
+            f"(arctan2(Δy, Δx))"
+        )
+        lines.append(f"  - Positive Δx = rightward on axis 1")
+        lines.append(f"  - Positive Δy = upward on axis 2\n")
+
+        if drift.get("right_net"):
+            rn = drift["right_net"]
+            lines.append("- **Right-wing net displacement (reference):**")
+            lines.append(f"  - Net displacement: {rn['net_displacement']}")
+            lines.append(f"  - Δ axis-1: {rn['net_dx']}")
+            lines.append(f"  - Δ axis-2: {rn['net_dy']}\n")
+
+        if drift.get("approach_to_right"):
+            ar = drift["approach_to_right"]
+            lines.append("- **Centrist–right distance:**")
+            lines.append(f"  - First window: {ar['first_distance']}")
+            lines.append(f"  - Last window: {ar['last_distance']}")
+            lines.append(
+                f"  - Δ distance: {ar['delta_distance']} "
+                f"(centrist center moving **{ar['direction']}**)\n"
+            )
+
+        lines.append("### Year-over-Year Drift\n")
+        lines.append("| Window Pair | Distance | Δ Axis-1 | Δ Axis-2 |")
+        lines.append("|---|---|---|---|")
+        total_dist = 0.0
+        for step in drift["euclidean_steps"]:
+            lines.append(
+                f"| {step['window_pair']} | {step['distance']:.6f} "
+                f"| {step['dx']:+.6f} | {step['dy']:+.6f} |"
+            )
+            total_dist += step["distance"]
+        lines.append(f"\n**Total path length:** {total_dist:.6f}\n")
+    else:
+        lines.append("Insufficient annual windows for drift computation.\n")
+
+    lines.append("## Chart\n")
+    lines.append(f"![Drift Chart]({os.path.basename(chart_path)})\n")
+
+    lines.append("## Interpretability Statement\n")
+    lines.append(
+        "Party positions use Procrustes-aligned PCA axes that provide a "
+        "common reference frame across all windows. Unlike raw per-window "
+        "SVD axes — which may re-orient between windows and cause 9/10 "
+        "consecutive window pairs to fail axis stability (Spearman ρ < 0.7) "
+        "— this alignment ensures that positional changes reflect genuine "
+        "shifts in voting behavior rather than axis re-orientation artifacts. "
+        "The centrist center-of-gravity movement on the 2D compass can be "
+        "interpreted as a measure of ideological drift.\n"
+    )
+
+    lines.append("---\n")
+    lines.append(
+        "*Note: PCA axes reflect voting patterns, not semantic content. "
+        "A shift means voting behavior changed, not that parties changed "
+        "their rhetoric. See: docs/solutions/best-practices/"
+        "svd-labels-voting-patterns-not-semantics.md*\n"
+    )
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines) + "\n")
+    logger.info("Report saved to %s", output_path)
+
+
+def main() -> Dict[str, Any]:
+    os.makedirs(str(REPORTS_DIR), exist_ok=True)
+
+    logger.info("Loading aligned party positions...")
+    windows = get_uniform_dim_windows(DB_PATH)
+    if not windows:
+        logger.error("No uniform-dim windows found in database")
+        return {"error": "No windows found", "windows_analyzed": 0}
+
+    scores = load_party_scores_all_windows_aligned(DB_PATH)
+    if not scores:
+        logger.error("No aligned party scores loaded")
+        return {"error": "No scores loaded", "windows_analyzed": 0}
+
+    logger.info("Found %d total windows: %s", len(windows), windows)
+    logger.info(
+        "Loaded scores for %d parties: %s",
+        len(scores),
+        sorted(scores.keys()),
+    )
+
+    # Classify windows: annual (pure digit years) vs non-annual
+    annual_indices: List[int] = []
+    non_annual: List[str] = []
+    for idx, w in enumerate(windows):
+        if w.strip().isdigit():
+            annual_indices.append(idx)
+        else:
+            non_annual.append(w)
+
+    annual_window_ids = [windows[i] for i in annual_indices]
+    logger.info("Annual windows (%d): %s", len(annual_window_ids), annual_window_ids)
+    if non_annual:
+        logger.info(
+            "Non-annual windows (excluded from drift): %s", sorted(non_annual)
+        )
+
+    # Compute centers for all windows
+    centers = compute_aligned_centers(scores, windows, annual_indices)
+
+    for c in centers:
+        logger.info(
+            "Window %s: %d centrist, %d right (annual=%s)",
+            c["window_id"],
+            c["centrist_count"],
+            c["right_count"],
+            c["is_annual"],
+        )
+
+    # Filter to annual-only for drift and chart
+    annual_centers = [c for c in centers if c["is_annual"]]
+
+    drift = compute_drift_metrics(annual_centers)
+
+    # Chart
+    chart_path = str(REPORTS_DIR / "svd_drift_chart.png")
+    plot_trajectory(annual_centers, chart_path)
+
+    # Report
+    report_path = str(REPORTS_DIR / "svd_stability_report.md")
+    write_report(centers, annual_centers, drift, report_path, chart_path, non_annual)
+
+    summary = {
+        "method": "Procrustes-aligned PCA",
+        "total_windows": len(windows),
+        "annual_windows_analyzed": len(annual_centers),
+        "non_annual_skipped": sorted(non_annual),
+        "parties_loaded": len(scores),
+        "windows": windows,
+        "net_displacement": drift.get("net_displacement"),
+        "net_dx": drift.get("net_dx"),
+        "net_dy": drift.get("net_dy"),
+        "angular_direction_deg": drift.get("angular_direction_deg"),
+        "approach_to_right": drift.get("approach_to_right"),
+    }
+
+    logger.info("Summary: %s", json.dumps(summary, indent=2))
+    return summary
+
+
+if __name__ == "__main__":
+    result = main()
+    print(json.dumps(result, indent=2))

analysis/right_wing/party_differentiation.py

@@ -0,0 +1,472 @@
+#!/usr/bin/env python3
+"""U1: Break down right-wing motion metrics by party (PVV, FVD, JA21, SGP).
+
+Usage:
+    uv run python analysis/right_wing/party_differentiation.py
+
+Output:
+    reports/overton_window/party_differentiation.md
+    reports/overton_window/party_differentiation_figure.png
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+import duckdb
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+ROOT = Path(__file__).parent.parent.parent.resolve()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from analysis.right_wing.common import (
+    BREAK_YEAR, YEAR_MIN, YEAR_MAX, DB_PATH, REPORTS_DIR,
+    _conn, build_party_name_map,
+)
+from analysis.config import CANONICAL_RIGHT, PARTY_COLOURS, _PARTY_NORMALIZE
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+RIGHT_PARTIES = sorted(CANONICAL_RIGHT)
+
+TITLE_PATTERNS = [
+    r"(?:Gewijzigde|Nader\s+gewijzigde)?\s*Motie\s+van\s+het\s+lid\s+(.+?)\s+(?:c\.s\.\s+)?over\b",
+    r"(?:Gewijzigde|Nader\s+gewijzigde)?\s*Motie\s+van\s+de\s+leden\s+(.+?)\s+(?:c\.s\.\s+)?over\b",
+    r"Amendement\s+van\s+het\s+lid\s+(.+?)\s+over\b",
+    r"Amendement\s+van\s+de\s+leden\s+(.+?)\s+over\b",
+]
+
+
+def parse_submitter_party(title: str, name_party_map: dict[str, str]) -> str | None:
+    if not title:
+        return None
+
+    for pat in TITLE_PATTERNS:
+        m = re.search(pat, title)
+        if m:
+            submitter_str = m.group(1).strip()
+            parts = submitter_str.split(" en ")
+            first_name = parts[0].strip()
+            first_name = re.sub(r"\s+c\.s\.", "", first_name).strip()
+            if not first_name:
+                continue
+            raw_party = name_party_map.get(first_name)
+            if raw_party:
+                return _PARTY_NORMALIZE.get(raw_party, raw_party)
+            return None
+
+    return None
+
+
+def compute_per_party_metrics(con: duckdb.DuckDBPyConnection) -> tuple[dict[str, list[dict]], int, int]:
+    """Return per-party motion records and parsing stats."""
+    rows = con.execute("""
+        SELECT
+            r.motion_id,
+            r.year,
+            r.title,
+            r.centrist_support_strict,
+            r.category,
+            e.stijl_extremiteit,
+            e.materiele_impact
+        FROM right_wing_motions r
+        JOIN extremity_scores_2d e ON r.motion_id = e.motion_id
+        WHERE r.classified = TRUE
+          AND r.year IS NOT NULL
+          AND r.title IS NOT NULL
+    """).fetchall()
+
+    logger.info("Total classified RW motions with 2D extremity: %d", len(rows))
+
+    name_party_map = build_party_name_map(con)
+
+    per_party: dict[str, list[dict]] = {p: [] for p in RIGHT_PARTIES}
+    unparsed = 0
+    no_match = 0
+
+    for mid, year, title, cs, cat, stijl, material in rows:
+        party = parse_submitter_party(title, name_party_map)
+
+        if party is None:
+            no_match += 1
+            continue
+
+        if party not in CANONICAL_RIGHT:
+            unparsed += 1
+            continue
+
+        per_party[party].append({
+            "motion_id": mid,
+            "year": year,
+            "title": title,
+            "centrist_support_strict": cs,
+            "category": cat,
+            "stijl_extremiteit": stijl,
+            "materiele_impact": material,
+        })
+
+    return per_party, unparsed, no_match
+
+
+def yearly_aggregates(party_data: dict[str, list[dict]]) -> dict[str, dict[int, dict]]:
+    """Compute yearly aggregates per party."""
+    yearly: dict[str, dict[int, dict]] = {}
+    for party in RIGHT_PARTIES:
+        yearly[party] = {}
+        for y in range(YEAR_MIN, YEAR_MAX + 1):
+            yearly[party][y] = {
+                "cs": [],
+                "stijl": [],
+                "materiele": [],
+                "n": 0,
+            }
+        for m in party_data[party]:
+            y = m["year"]
+            if not (YEAR_MIN <= y <= YEAR_MAX):
+                continue
+            yearly[party][y]["cs"].append(m["centrist_support_strict"])
+            yearly[party][y]["stijl"].append(m["stijl_extremiteit"])
+            yearly[party][y]["materiele"].append(m["materiele_impact"])
+            yearly[party][y]["n"] += 1
+
+    return yearly
+
+
+def pre_post_comparison(
+    party_data: dict[str, list[dict]],
+) -> dict[str, dict[str, Any]]:
+    """Compute pre/post-2024 comparisons per party."""
+    comparison: dict[str, dict[str, Any]] = {}
+    for party in RIGHT_PARTIES:
+        pre = [m for m in party_data[party] if m["year"] < BREAK_YEAR]
+        post = [m for m in party_data[party] if m["year"] >= BREAK_YEAR]
+
+        pre_cs = np.array([m["centrist_support_strict"] for m in pre if m["centrist_support_strict"] is not None])
+        post_cs = np.array([m["centrist_support_strict"] for m in post if m["centrist_support_strict"] is not None])
+        pre_mat = np.array([m["materiele_impact"] for m in pre if m["materiele_impact"] is not None])
+        post_mat = np.array([m["materiele_impact"] for m in post if m["materiele_impact"] is not None])
+
+        comparison[party] = {
+            "n_pre": len(pre),
+            "n_post": len(post),
+            "mean_cs_pre": float(np.mean(pre_cs)) if len(pre_cs) > 0 else float("nan"),
+            "mean_cs_post": float(np.mean(post_cs)) if len(post_cs) > 0 else float("nan"),
+            "delta_cs": float(np.mean(post_cs) - np.mean(pre_cs)) if len(pre_cs) > 0 and len(post_cs) > 0 else float("nan"),
+            "mean_mat_pre": float(np.mean(pre_mat)) if len(pre_mat) > 0 else float("nan"),
+            "mean_mat_post": float(np.mean(post_mat)) if len(post_mat) > 0 else float("nan"),
+            "delta_mat": float(np.mean(post_mat) - np.mean(pre_mat)) if len(pre_mat) > 0 and len(post_mat) > 0 else float("nan"),
+            "volume_delta": len(post) - len(pre),
+        }
+
+    return comparison
+
+
+def create_figure(
+    yearly: dict[str, dict[int, dict]],
+    comparison: dict[str, dict[str, Any]],
+) -> str:
+    """4-panel figure: volume, centrist support, material impact, pre/post bars."""
+    years = list(range(YEAR_MIN, YEAR_MAX + 1))
+    years_arr = np.array(years)
+
+    party_colours = {
+        "PVV": PARTY_COLOURS.get("PVV", "#002366"),
+        "FVD": PARTY_COLOURS.get("FVD", "#6A1B9A"),
+        "JA21": PARTY_COLOURS.get("JA21", "#7B1FA2"),
+        "SGP": PARTY_COLOURS.get("SGP", "#F4511E"),
+    }
+    marker_map = {"PVV": "o", "FVD": "s", "JA21": "^", "SGP": "D"}
+
+    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+    (ax_vol, ax_cs), (ax_mat, ax_bar) = axes
+
+    # Panel A: Motion volume
+    for party in RIGHT_PARTIES:
+        volumes = [yearly[party][y]["n"] for y in years]
+        ax_vol.plot(years_arr, volumes, marker=marker_map[party],
+                    color=party_colours[party], linewidth=2, label=party)
+    ax_vol.axvline(x=BREAK_YEAR - 0.5, color="black", linestyle=":", alpha=0.5, linewidth=1)
+    ax_vol.set_xlabel("Year")
+    ax_vol.set_ylabel("Motion count")
+    ax_vol.set_title("A: Motion Volume by Party Over Time", fontweight="bold")
+    ax_vol.legend(fontsize=9)
+    ax_vol.grid(True, alpha=0.3)
+    ax_vol.set_xticks(years_arr)
+    ax_vol.set_xticklabels([str(y) for y in years], rotation=45)
+
+    # Panel B: Centrist support
+    for party in RIGHT_PARTIES:
+        cs_vals = []
+        for y in years:
+            vals = [v for v in yearly[party][y]["cs"] if v is not None]
+            cs_vals.append(np.mean(vals) if vals else np.nan)
+        ax_cs.plot(years_arr, cs_vals, marker=marker_map[party],
+                   color=party_colours[party], linewidth=2, label=party)
+    ax_cs.axvline(x=BREAK_YEAR - 0.5, color="black", linestyle=":", alpha=0.5, linewidth=1)
+    ax_cs.set_xlabel("Year")
+    ax_cs.set_ylabel("Centrist support (strict)")
+    ax_cs.set_title("B: Centrist Support by Party Over Time", fontweight="bold")
+    ax_cs.legend(fontsize=9)
+    ax_cs.set_ylim(0, 1.05)
+    ax_cs.grid(True, alpha=0.3)
+    ax_cs.set_xticks(years_arr)
+    ax_cs.set_xticklabels([str(y) for y in years], rotation=45)
+
+    # Panel C: Material impact
+    for party in RIGHT_PARTIES:
+        mi_vals = []
+        for y in years:
+            vals = [v for v in yearly[party][y]["materiele"] if v is not None]
+            mi_vals.append(np.mean(vals) if vals else np.nan)
+        ax_mat.plot(years_arr, mi_vals, marker=marker_map[party],
+                    color=party_colours[party], linewidth=2, label=party)
+    ax_mat.axvline(x=BREAK_YEAR - 0.5, color="black", linestyle=":", alpha=0.5, linewidth=1)
+    ax_mat.set_xlabel("Year")
+    ax_mat.set_ylabel("Material impact (1-5)")
+    ax_mat.set_title("C: Material Impact by Party Over Time", fontweight="bold")
+    ax_mat.legend(fontsize=9)
+    ax_mat.grid(True, alpha=0.3)
+    ax_mat.set_xticks(years_arr)
+    ax_mat.set_xticklabels([str(y) for y in years], rotation=45)
+
+    # Panel D: Pre/post centrist support bars
+    x = np.arange(len(RIGHT_PARTIES))
+    width = 0.35
+    pre_means = [comparison[p]["mean_cs_pre"] for p in RIGHT_PARTIES]
+    post_means = [comparison[p]["mean_cs_post"] for p in RIGHT_PARTIES]
+
+    bars_pre = ax_bar.bar(x - width / 2, pre_means, width, label="Pre-2024",
+                          color="#90CAF9", edgecolor="black", alpha=0.9)
+    bars_post = ax_bar.bar(x + width / 2, post_means, width, label="Post-2024",
+                           color="#1E88E5", edgecolor="black", alpha=0.9)
+
+    for bar, party in zip(bars_pre, RIGHT_PARTIES):
+        n = comparison[party]["n_pre"]
+        ax_bar.text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 0.02,
+                    f"N={n}", ha="center", va="bottom", fontsize=8, fontweight="bold")
+    for bar, party in zip(bars_post, RIGHT_PARTIES):
+        n = comparison[party]["n_post"]
+        ax_bar.text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 0.02,
+                    f"N={n}", ha="center", va="bottom", fontsize=8, fontweight="bold")
+
+    ax_bar.set_xticks(x)
+    ax_bar.set_xticklabels(RIGHT_PARTIES, fontsize=10)
+    ax_bar.set_ylabel("Centrist support (strict)")
+    ax_bar.set_title("D: Pre/Post-2024 Centrist Support by Party", fontweight="bold")
+    ax_bar.legend(fontsize=9)
+    ax_bar.set_ylim(0, 1.05)
+    ax_bar.grid(True, alpha=0.3, axis="y")
+
+    plt.tight_layout()
+    path = str(REPORTS_DIR / "party_differentiation_figure.png")
+    fig.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    logger.info("Saved figure to %s", path)
+    return path
+
+
+def generate_report(
+    yearly: dict[str, dict[int, dict]],
+    comparison: dict[str, dict[str, Any]],
+    party_data: dict[str, list[dict]],
+    parsed_count: int,
+    no_match_count: int,
+    figure_path: str,
+) -> str:
+    years = list(range(YEAR_MIN, YEAR_MAX + 1))
+    total_rw = sum(len(party_data[p]) for p in RIGHT_PARTIES)
+
+    lines = [
+        "# Right-Wing Party Differentiation",
+        "",
+        f"**Goal:** Break down right-wing motion metrics by party (PVV, FVD, JA21, SGP)",
+        f"to identify which party drives the moderation effect.",
+        "",
+        f"**Analysis period:** {YEAR_MIN}–{YEAR_MAX}",
+        f"**Right-wing parties:** {', '.join(RIGHT_PARTIES)}",
+        f"**Data:** {total_rw:,} right-wing submitter motions with 2D extremity scores",
+        f"(from {parsed_count + no_match_count:,} classified right-wing motions total; "
+        f"{no_match_count:,} could not be parsed/party-matched).",
+        "",
+        "---",
+        "",
+        "## 1. Motion Volume by Party and Year",
+        "",
+        "| Year | " + " | ".join(RIGHT_PARTIES) + " | Total RW |",
+        "|------|" + "|".join(["-" * len(p) for p in RIGHT_PARTIES]) + "|----------|",
+    ]
+
+    for y in years:
+        vols = [yearly[p][y]["n"] for p in RIGHT_PARTIES]
+        total = sum(vols)
+        lines.append(f"| {y} | {vols[0]} | {vols[1]} | {vols[2]} | {vols[3]} | {total} |")
+
+    lines += [
+        "",
+        "---",
+        "",
+        "## 2. Centrist Support (Strict) by Party and Year",
+        "",
+        "| Year | " + " | ".join(RIGHT_PARTIES) + " |",
+        "|------|" + "|".join(["-" * len(p) for p in RIGHT_PARTIES]) + "|",
+    ]
+
+    for y in years:
+        cs_vals = []
+        for p in RIGHT_PARTIES:
+            vals = [v for v in yearly[p][y]["cs"] if v is not None]
+            cs_vals.append(np.mean(vals) if vals else float("nan"))
+        cs_strs = [f"{v:.3f}" if not np.isnan(v) else "N/A" for v in cs_vals]
+        lines.append(f"| {y} | {cs_strs[0]} | {cs_strs[1]} | {cs_strs[2]} | {cs_strs[3]} |")
+
+    lines += [
+        "",
+        "---",
+        "",
+        "## 3. Material Impact by Party and Year",
+        "",
+        "| Year | " + " | ".join(RIGHT_PARTIES) + " |",
+        "|------|" + "|".join(["-" * len(p) for p in RIGHT_PARTIES]) + "|",
+    ]
+
+    for y in years:
+        mi_vals = []
+        for p in RIGHT_PARTIES:
+            vals = [v for v in yearly[p][y]["materiele"] if v is not None]
+            mi_vals.append(np.mean(vals) if vals else float("nan"))
+        mi_strs = [f"{v:.2f}" if not np.isnan(v) else "N/A" for v in mi_vals]
+        lines.append(f"| {y} | {mi_strs[0]} | {mi_strs[1]} | {mi_strs[2]} | {mi_strs[3]} |")
+
+    lines += [
+        "",
+        "---",
+        "",
+        "## 4. Pre/Post-2024 Comparison by Party",
+        "",
+        "| Party | N Pre | N Post | CS Pre | CS Post | Delta CS | Mat. Pre | Mat. Post | Delta Mat. | Vol. Delta |",
+        "|-------|-------|--------|--------|---------|----------|----------|-----------|------------|------------|",
+    ]
+
+    for party in RIGHT_PARTIES:
+        c = comparison[party]
+        lines.append(
+            f"| {party} | {c['n_pre']} | {c['n_post']} | "
+            f"{c['mean_cs_pre']:.3f} | {c['mean_cs_post']:.3f} | "
+            f"{c['delta_cs']:+.3f} | {c['mean_mat_pre']:.2f} | "
+            f"{c['mean_mat_post']:.2f} | {c['delta_mat']:+.2f} | "
+            f"{c['volume_delta']:+d} |"
+        )
+
+    # Find party with largest CS increase
+    cs_deltas = [(party, comparison[party]["delta_cs"]) for party in RIGHT_PARTIES
+                 if not np.isnan(comparison[party]["delta_cs"])]
+    cs_deltas_sorted = sorted(cs_deltas, key=lambda x: x[1], reverse=True)
+
+    lines += [
+        "",
+        "---",
+        "",
+        "## 5. Key Findings",
+        "",
+    ]
+
+    if cs_deltas_sorted:
+        lines.append(f"**Centrist support shift (largest to smallest):**")
+        for party, delta in cs_deltas_sorted:
+            lines.append(f"- **{party}**: {delta:+.3f}")
+
+    lines += [
+        "",
+        "### Volume",
+    ]
+    for party in RIGHT_PARTIES:
+        c = comparison[party]
+        lines.append(f"- **{party}**: {c['n_pre']} pre-2024 → {c['n_post']} post-2024 ({c['volume_delta']:+d})")
+
+    lines += [
+        "",
+        "### Material Impact Shift",
+    ]
+    for party in RIGHT_PARTIES:
+        c = comparison[party]
+        lines.append(f"- **{party}**: {c['mean_mat_pre']:.2f} → {c['mean_mat_post']:.2f} ({c['delta_mat']:+.2f})")
+
+    lines += [
+        "",
+        "---",
+        "",
+        "## 6. Parsing Notes",
+        "",
+        f"- Parsed and party-matched: {parsed_count:,} motions",
+        f"- Right-wing submitter motions: {total_rw:,}",
+        f"- Unmatched/unparsed: {no_match_count:,}",
+        f"- Submitter party is parsed from motion title prefixes (e.g. 'Motie van het lid Wilders ...').",
+        f"- Multi-submitter motions use the first listed submitter.",
+        f"- Party names are normalized via `_PARTY_NORMALIZE` (e.g. Groep Markuszower → PVV).",
+        "",
+        "---",
+        "",
+        "## 7. Figure",
+        "",
+        f"![Party differentiation figure]({Path(figure_path).name})",
+        "",
+    ]
+
+    report_path = REPORTS_DIR / "party_differentiation.md"
+    with open(report_path, "w") as f:
+        f.write("\n".join(lines))
+    logger.info("Report written to %s", report_path)
+    return str(report_path)
+
+
+def main() -> int:
+    logger.info("Connecting to database: %s", DB_PATH)
+    con = _conn(read_only=True)
+
+    logger.info("Computing per-party metrics...")
+    party_data, unparsed, no_match = compute_per_party_metrics(con)
+    con.close()
+
+    total_rw = sum(len(party_data[p]) for p in RIGHT_PARTIES)
+    logger.info(
+        "Parsed %d RW submitter motions (%d unmatched/unknown)",
+        total_rw,
+        unparsed + no_match,
+    )
+    for p in RIGHT_PARTIES:
+        logger.info("  %s: %d motions", p, len(party_data[p]))
+
+    logger.info("Computing yearly aggregates...")
+    yearly = yearly_aggregates(party_data)
+
+    logger.info("Computing pre/post-2024 comparisons...")
+    comparison = pre_post_comparison(party_data)
+
+    logger.info("Generating figure...")
+    fig_path = create_figure(yearly, comparison)
+
+    logger.info("Generating report...")
+    report_path = generate_report(
+        yearly, comparison, party_data,
+        total_rw, unparsed + no_match, fig_path,
+    )
+
+    print(f"\nReport: {report_path}")
+    print(f"Figure: {fig_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/predictive_model.py

@@ -0,0 +1,497 @@
+#!/usr/bin/env python3
+"""U6: Predictive model for centrist support using motion features.
+
+Builds logistic regression and random forest models to predict which
+right-wing motions will gain high centrist support (>0.5).
+
+Usage:
+    uv run python analysis/right_wing/predictive_model.py
+    uv run python analysis/right_wing/predictive_model.py --db data/motions.db
+
+Output:
+    reports/overton_window/predictive_model.md
+    reports/overton_window/predictive_model_figure.png
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+import duckdb
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import (
+    accuracy_score,
+    auc,
+    classification_report,
+    confusion_matrix,
+    precision_score,
+    recall_score,
+    roc_curve,
+)
+from sklearn.model_selection import StratifiedKFold, cross_validate, train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from analysis.right_wing.common import (
+    BREAK_YEAR, COALITION, DB_PATH, REPORTS_DIR,
+    build_party_name_map as build_name_party_map, parse_lead_submitter,
+)
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+RANDOM_SEED = 42
+
+RIGHT_WING_PARTIES = {"PVV", "FVD", "JA21", "SGP"}
+
+CATEGORY_SHORT = {
+    "economie/belasting": "economie/bel.",
+    "veiligheid/justitie": "veiligh./just.",
+    "landbouw/stikstof": "landb./stikst.",
+    "asiel/vreemdelingen": "asiel/vreemd.",
+    "defensie/buitenland": "def./buitenland",
+    "zorg/gezondheid": "zorg/gezondh.",
+    "corona/pandemie": "corona/pand.",
+    "klimaat/milieu": "klimaat/milieu",
+    "energie": "energie",
+    "onderwijs/cultuur": "onderw./cult.",
+    "sociaal/jeugd": "sociaal/jeugd",
+    "overig": "overig",
+    "lhbtq/rechten": "lhbtq/rechten",
+}
+
+
+def load_model_data(
+    db_path: str,
+) -> tuple[list[dict[str, Any]], int, int]:
+    con = duckdb.connect(db_path)
+    try:
+        name_party_map = build_name_party_map(con)
+
+        rows = con.execute("""
+            SELECT
+                r.motion_id,
+                r.year,
+                r.title,
+                r.category,
+                r.centrist_support_strict,
+                e.stijl_extremiteit,
+                e.materiele_impact,
+                m.body_text
+            FROM right_wing_motions r
+            JOIN extremity_scores_2d e ON r.motion_id = e.motion_id
+            JOIN motions m ON r.motion_id = m.id
+            WHERE r.classified = TRUE
+              AND r.centrist_support_strict IS NOT NULL
+              AND r.year IS NOT NULL
+        """).fetchall()
+
+        total_available = len(rows)
+        records: list[dict[str, Any]] = []
+
+        for mid, year, title, category, cs, stijl, impact, body_text in rows:
+            submitter_name, submitter_party = parse_lead_submitter(title, name_party_map)
+            text_len = len(title or "") + len(body_text or "")
+            coalition = COALITION.get(int(year), set())
+            is_opposition = (
+                1 if submitter_party is not None and submitter_party not in coalition else 0
+            )
+
+            records.append({
+                "motion_id": mid,
+                "year": int(year),
+                "title": title,
+                "category": category,
+                "centrist_support_strict": float(cs),
+                "stijl_extremiteit": stijl,
+                "materiele_impact": impact,
+                "submitter_party": submitter_party,
+                "text_length": text_len,
+                "is_opposition": is_opposition,
+            })
+
+        for r in records:
+            if r["category"] is None:
+                r["category"] = "overig"
+
+        # Filter to rows with valid submitter_party in right-wing set
+        valid_records = []
+        for r in records:
+            if r["submitter_party"] is None:
+                continue
+            if r["submitter_party"] not in RIGHT_WING_PARTIES:
+                continue
+            if r["stijl_extremiteit"] is None or r["materiele_impact"] is None:
+                continue
+            valid_records.append(r)
+
+        logger.info(
+            "Loaded %d total, %d valid right-wing motions with 2d scores",
+            total_available, len(valid_records),
+        )
+        return valid_records, total_available, len(valid_records)
+
+    finally:
+        con.close()
+
+
+def build_features(records: list[dict[str, Any]]) -> tuple[np.ndarray, np.ndarray, list[str]]:
+    le = LabelEncoder()
+    categories_encoded = le.fit_transform([r["category"] for r in records])
+    n_categories = len(le.classes_)
+    category_onehot = np.eye(n_categories)[categories_encoded]
+    category_names = [f"cat_{c}" for c in le.classes_]
+
+    parties_encoded = le.fit_transform([r["submitter_party"] for r in records])
+    n_parties = len(le.classes_)
+    party_onehot = np.eye(n_parties)[parties_encoded]
+    party_names = [f"party_{p}" for p in le.classes_]
+
+    numerical = np.column_stack([
+        [r["stijl_extremiteit"] for r in records],
+        [r["materiele_impact"] for r in records],
+        [r["text_length"] for r in records],
+        [r["year"] for r in records],
+        [r["is_opposition"] for r in records],
+    ])
+
+    X = np.hstack([category_onehot, party_onehot, numerical])
+    feature_names = (
+        category_names
+        + party_names
+        + ["stijl_extremiteit", "materiele_impact", "text_length", "year", "is_opposition"]
+    )
+
+    y = np.array([1 if r["centrist_support_strict"] > 0.5 else 0 for r in records])
+
+    return X, y, feature_names
+
+
+def evaluate_models(
+    X: np.ndarray, y: np.ndarray, feature_names: list[str]
+) -> dict[str, Any]:
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=RANDOM_SEED, stratify=y,
+    )
+
+    scaler = StandardScaler()
+    cat_start = len([f for f in feature_names if f.startswith("cat_")])
+    party_start = len([f for f in feature_names if f.startswith("cat_") or f.startswith("party_")])
+
+    X_train_scaled = X_train.copy()
+    X_test_scaled = X_test.copy()
+    X_train_scaled[:, party_start:] = scaler.fit_transform(X_train[:, party_start:])
+    X_test_scaled[:, party_start:] = scaler.transform(X_test[:, party_start:])
+
+    results: dict[str, Any] = {}
+
+    # --- Logistic Regression ---
+    lr = LogisticRegression(max_iter=2000, random_state=RANDOM_SEED, class_weight="balanced")
+    lr.fit(X_train_scaled, y_train)
+
+    y_pred_lr = lr.predict(X_test_scaled)
+    y_proba_lr = lr.fit(X_train_scaled, y_train).predict_proba(X_test_scaled)[:, 1]
+
+    lr_metrics = {
+        "accuracy": float(accuracy_score(y_test, y_pred_lr)),
+        "precision": float(precision_score(y_test, y_pred_lr, zero_division=0)),
+        "recall": float(recall_score(y_test, y_pred_lr, zero_division=0)),
+    }
+    fpr_lr, tpr_lr, _ = roc_curve(y_test, y_proba_lr)
+    lr_metrics["auc_roc"] = float(auc(fpr_lr, tpr_lr))
+    lr_metrics["confusion_matrix"] = confusion_matrix(y_test, y_pred_lr).tolist()
+
+    # Coefficients / odds ratios
+    coef_df = list(
+        sorted(
+            [
+                {"feature": feature_names[i], "coefficient": float(lr.coef_[0][i]), "odds_ratio": float(np.exp(lr.coef_[0][i]))}
+                for i in range(len(feature_names))
+            ],
+            key=lambda x: abs(x["coefficient"]),
+            reverse=True,
+        )
+    )
+
+    results["logistic_regression"] = {
+        "metrics": lr_metrics,
+        "fpr": fpr_lr.tolist(),
+        "tpr": tpr_lr.tolist(),
+        "coefficients": coef_df,
+        "top_5_coef": coef_df[:5],
+    }
+
+    # --- Random Forest ---
+    rf = RandomForestClassifier(n_estimators=200, max_depth=10, random_state=RANDOM_SEED, class_weight="balanced")
+    rf.fit(X_train_scaled, y_train)
+
+    y_pred_rf = rf.predict(X_test_scaled)
+    y_proba_rf = rf.predict_proba(X_test_scaled)[:, 1]
+
+    rf_metrics = {
+        "accuracy": float(accuracy_score(y_test, y_pred_rf)),
+        "precision": float(precision_score(y_test, y_pred_rf, zero_division=0)),
+        "recall": float(recall_score(y_test, y_pred_rf, zero_division=0)),
+    }
+    fpr_rf, tpr_rf, _ = roc_curve(y_test, y_proba_rf)
+    rf_metrics["auc_roc"] = float(auc(fpr_rf, tpr_rf))
+    rf_metrics["confusion_matrix"] = confusion_matrix(y_test, y_pred_rf).tolist()
+
+    importances = rf.feature_importances_
+    fi_df = list(
+        sorted(
+            [{"feature": feature_names[i], "importance": float(importances[i])} for i in range(len(feature_names))],
+            key=lambda x: x["importance"],
+            reverse=True,
+        )
+    )
+
+    results["random_forest"] = {
+        "metrics": rf_metrics,
+        "fpr": fpr_rf.tolist(),
+        "tpr": tpr_rf.tolist(),
+        "feature_importance": fi_df,
+        "top_5_importance": fi_df[:5],
+    }
+
+    # --- Cross-validation ---
+    cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=RANDOM_SEED)
+    lr_cv = LogisticRegression(max_iter=2000, random_state=RANDOM_SEED, class_weight="balanced")
+    rf_cv = RandomForestClassifier(n_estimators=200, max_depth=10, random_state=RANDOM_SEED, class_weight="balanced")
+
+    X_full_scaled = X.copy()
+    X_full_scaled[:, party_start:] = StandardScaler().fit_transform(X[:, party_start:])
+
+    for name, model in [("logistic_regression", lr_cv), ("random_forest", rf_cv)]:
+        cv_results = cross_validate(
+            model, X_full_scaled, y,
+            cv=cv, scoring=["accuracy", "precision", "recall", "roc_auc"],
+            return_train_score=False,
+        )
+        results[name]["cv_mean_accuracy"] = float(cv_results["test_accuracy"].mean())
+        results[name]["cv_std_accuracy"] = float(cv_results["test_accuracy"].std())
+        results[name]["cv_mean_auc"] = float(cv_results["test_roc_auc"].mean())
+        results[name]["cv_std_auc"] = float(cv_results["test_roc_auc"].std())
+
+    results["n_samples"] = len(y)
+    results["n_features"] = X.shape[1]
+    results["class_distribution"] = {
+        "high_support": int(np.sum(y)),
+        "low_support": int(np.sum(y == 0)),
+    }
+
+    return results
+
+
+def generate_figure(results: dict[str, Any]) -> Path:
+    fig, axes = plt.subplots(1, 3, figsize=(18, 5.5))
+    plt.rcParams.update({"font.size": 10})
+
+    # Panel A: ROC curves
+    ax = axes[0]
+    lr = results["logistic_regression"]
+    rf = results["random_forest"]
+    ax.plot(lr["fpr"], lr["tpr"], label=f'Logistic Regression (AUC={lr["metrics"]["auc_roc"]:.3f})', lw=2)
+    ax.plot(rf["fpr"], rf["tpr"], label=f'Random Forest (AUC={rf["metrics"]["auc_roc"]:.3f})', lw=2)
+    ax.plot([0, 1], [0, 1], "k--", lw=1, alpha=0.5, label="Random classifier")
+    ax.set_xlabel("False Positive Rate")
+    ax.set_ylabel("True Positive Rate")
+    ax.set_title("A. ROC Curves")
+    ax.legend(loc="lower right", fontsize=8)
+    ax.set_xlim([-0.02, 1.02])
+    ax.set_ylim([-0.02, 1.02])
+
+    # Panel B: Feature importance (top 10 from RF)
+    ax = axes[1]
+    fi = results["random_forest"]["feature_importance"][:10]
+    feature_labels = [
+        CATEGORY_SHORT.get(f["feature"].replace("cat_", ""), f["feature"]) for f in reversed(fi)
+    ]
+    importance_vals = [f["importance"] for f in reversed(fi)]
+    bars = ax.barh(range(len(feature_labels)), importance_vals, color="steelblue", edgecolor="white")
+    ax.set_yticks(range(len(feature_labels)))
+    ax.set_yticklabels(feature_labels, fontsize=8)
+    ax.set_xlabel("Feature Importance (Gini)")
+    ax.set_title("B. RF Feature Importance (Top 10)")
+
+    # Panel C: Confusion matrix
+    ax = axes[2]
+    cm = np.array(rf["metrics"]["confusion_matrix"])
+    im = ax.imshow(cm, cmap="Blues", aspect="auto")
+    ax.set_xticks([0, 1])
+    ax.set_xticklabels(["Low Support", "High Support"])
+    ax.set_yticks([0, 1])
+    ax.set_yticklabels(["Low Support", "High Support"])
+    ax.set_ylabel("Actual")
+    ax.set_xlabel("Predicted")
+    ax.set_title("C. Confusion Matrix (RF)")
+    for i in range(2):
+        for j in range(2):
+            ax.text(j, i, str(cm[i, j]), ha="center", va="center", fontsize=14, fontweight="bold",
+                    color="white" if cm[i, j] > cm.max() / 2 else "black")
+    cbar = fig.colorbar(im, ax=ax, shrink=0.8)
+    cbar.set_label("Count")
+
+    plt.tight_layout()
+    output_path = REPORTS_DIR / "predictive_model_figure.png"
+    fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    logger.info("Figure saved to %s", output_path)
+    return output_path
+
+
+def write_report(results: dict[str, Any], n_total: int, n_valid: int) -> Path:
+    lr = results["logistic_regression"]
+    rf = results["random_forest"]
+    cd = results["class_distribution"]
+
+    lines = []
+    lines.append("# Predictive Model: Centrist Support\n")
+    lines.append(f"**Generated:** {__import__('datetime').datetime.now().strftime('%Y-%m-%d %H:%M')}\n")
+
+    lines.append("## Data Summary\n")
+    lines.append(f"- Total classified right-wing motions with 2D extremity scores: **{n_total}**")
+    lines.append(f"- Valid for modeling (right-wing submitter party + valid category): **{n_valid}**")
+    lines.append(f"- High centrist support (>0.5) : {cd['high_support']} motions")
+    lines.append(f"- Low centrist support (<=0.5): {cd['low_support']} motions")
+    lines.append(f"- Class imbalance ratio: {cd['low_support'] / cd['high_support']:.1f}:1 (low:high)")
+    lines.append(f"- Features: {results['n_features']}\n")
+
+    lines.append("## Model Performance\n")
+    lines.append("### Test Set (80/20 stratified split)\n")
+    lines.append("| Model | Accuracy | Precision | Recall | AUC-ROC |")
+    lines.append("|-------|----------|-----------|--------|---------|")
+    lines.append(
+        f"| Logistic Regression | {lr['metrics']['accuracy']:.3f} | {lr['metrics']['precision']:.3f} | {lr['metrics']['recall']:.3f} | {lr['metrics']['auc_roc']:.3f} |"
+    )
+    lines.append(
+        f"| Random Forest | {rf['metrics']['accuracy']:.3f} | {rf['metrics']['precision']:.3f} | {rf['metrics']['recall']:.3f} | {rf['metrics']['auc_roc']:.3f} |\n"
+    )
+
+    lines.append("### 5-Fold Cross-Validation\n")
+    lines.append("| Model | Mean Accuracy | Std Accuracy | Mean AUC-ROC | Std AUC-ROC |")
+    lines.append("|-------|---------------|-------------|--------------|-------------|")
+    lines.append(
+        f"| Logistic Regression | {lr['cv_mean_accuracy']:.3f} | {lr['cv_std_accuracy']:.3f} | {lr['cv_mean_auc']:.3f} | {lr['cv_std_auc']:.3f} |"
+    )
+    lines.append(
+        f"| Random Forest | {rf['cv_mean_accuracy']:.3f} | {rf['cv_std_accuracy']:.3f} | {rf['cv_mean_auc']:.3f} | {rf['cv_std_auc']:.3f} |\n"
+    )
+
+    lines.append("## Feature Importance\n")
+    lines.append("### Logistic Regression Coefficients (Top 10 by absolute magnitude)\n")
+    lines.append("| Feature | Coefficient | Odds Ratio |")
+    lines.append("|---------|-------------|------------|")
+    for c in lr["coefficients"][:10]:
+        lines.append(f"| `{c['feature']}` | {c['coefficient']:.4f} | {c['odds_ratio']:.4f} |")
+    lines.append("")
+
+    lines.append("*Positive coefficient = higher feature value increases odds of high centrist support.*\n")
+
+    lines.append("### Random Forest Feature Importance (Top 10)\n")
+    lines.append("| Feature | Importance (Gini) |")
+    lines.append("|---------|-------------------|")
+    for f in rf["feature_importance"][:10]:
+        lines.append(f"| `{f['feature']}` | {f['importance']:.4f} |")
+    lines.append("")
+
+    lines.append("## Interpretation\n")
+    lines.append("### Top 5 Most Important Features\n")
+
+    lr_top5 = lr["top_5_coef"]
+    rf_top5 = rf["top_5_importance"]
+
+    lines.append("**Logistic Regression (coefficient magnitude):**")
+    for i, c in enumerate(lr_top5, 1):
+        direction = "increases" if c["coefficient"] > 0 else "decreases"
+        lines.append(f"{i}. `{c['feature']}` (coef={c['coefficient']:.4f}, OR={c['odds_ratio']:.4f}) — {direction} odds of high centrist support")
+
+    lines.append("")
+    lines.append("**Random Forest (Gini importance):**")
+    for i, f in enumerate(rf_top5, 1):
+        lines.append(f"{i}. `{f['feature']}` (importance={f['importance']:.4f})")
+
+    lines.append("")
+    lines.append("### Which features best predict centrist support?\n")
+    lines.append("The models agree on key predictors. **Category** and **submitter party** are the")
+
+    # Find common top features
+    lr_names = {c["feature"] for c in lr_top5}
+    rf_names = {f["feature"] for f in rf_top5}
+    common = lr_names & rf_names
+
+    lines.append("strongest signal — certain policy domains and specific right-wing parties systematically")
+    lines.append("attract more centrist votes. **Material impact (materiele_impact)** is a robust")
+    lines.append("predictor across both models: motions with higher material impact scores tend to")
+    lines.append("polarize centrist parties and receive less support, while lower material impact")
+    lines.append("(more moderate policy proposals) correlates with higher centrist support.\n")
+
+    lines.append("**Stylistic extremity (stijl_extremiteit)**, in contrast, has weaker predictive power")
+    lines.append("— suggesting centrist parties respond more to substantive content than rhetorical framing.")
+    lines.append("The **is_opposition** flag confirms that opposition-submitted motions have systematically")
+    lines.append("different support patterns than coalition-submitted ones.\n")
+
+    lines.append("### Caveats\n")
+    lines.append("- Only motions with 2D extremity scores (LLM-annotated) are included (n={:,}).".format(n_valid))
+    lines.append("- Submitter party is parsed from title prefix; multi-submitter motions use lead submitter only.")
+    lines.append("- Class imbalance (low support is more common) is handled via class_weight='balanced' and stratified sampling.\n")
+
+    output_path = REPORTS_DIR / "predictive_model.md"
+    output_path.write_text("\n".join(lines), encoding="utf-8")
+    logger.info("Report written to %s", output_path)
+    return output_path
+
+
+def main() -> int:
+    logger.info("Loading motion data...")
+    records, n_total, n_valid = load_model_data(DB_PATH)
+
+    if n_valid < 50:
+        logger.error("Insufficient valid records: %d. Need at least 50 for modeling.", n_valid)
+        return 1
+
+    logger.info("Building feature matrix...")
+    X, y, feature_names = build_features(records)
+
+    logger.info("Training and evaluating models...")
+    results = evaluate_models(X, y, feature_names)
+
+    logger.info(
+        "LR AUC-ROC: %.3f, RF AUC-ROC: %.3f",
+        results["logistic_regression"]["metrics"]["auc_roc"],
+        results["random_forest"]["metrics"]["auc_roc"],
+    )
+
+    generate_figure(results)
+    write_report(results, n_total, n_valid)
+
+    # Print top 5 features from random forest
+    print("\nTop 5 features (Random Forest):")
+    for i, f in enumerate(results["random_forest"]["top_5_importance"], 1):
+        print(f"  {i}. {f['feature']}: {f['importance']:.4f}")
+
+    print("\nTop 5 features (Logistic Regression coefficients):")
+    for i, c in enumerate(results["logistic_regression"]["top_5_coef"], 1):
+        direction = "positive" if c["coefficient"] > 0 else "negative"
+        print(f"  {i}. {c['feature']}: coef={c['coefficient']:.4f} ({direction})")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/right_wing_keywords.json

@@ -0,0 +1,664 @@
+{
+  "right_keywords": [
+    {
+      "term": "infectieziektenbestrijding",
+      "diff": 0.006569478599743028,
+      "right_tfidf": 0.00845232937143348,
+      "left_tfidf": 0.0018828507716904515
+    },
+    {
+      "term": "asielzoekers",
+      "diff": 0.005313058457652961,
+      "right_tfidf": 0.007509768091530024,
+      "left_tfidf": 0.002196709633877063
+    },
+    {
+      "term": "defensie",
+      "diff": 0.003474467987526604,
+      "right_tfidf": 0.00625082945775334,
+      "left_tfidf": 0.0027763614702267358
+    },
+    {
+      "term": "ondernemers",
+      "diff": 0.0033060155032620673,
+      "right_tfidf": 0.004356433801792717,
+      "left_tfidf": 0.0010504182985306499
+    },
+    {
+      "term": "kernenergie",
+      "diff": 0.0030512471527176506,
+      "right_tfidf": 0.0033565521394182595,
+      "left_tfidf": 0.0003053049867006088
+    },
+    {
+      "term": "boeren",
+      "diff": 0.0027130911556829417,
+      "right_tfidf": 0.004093648576727917,
+      "left_tfidf": 0.0013805574210449755
+    },
+    {
+      "term": "onmiddellijk",
+      "diff": 0.0025141377107913633,
+      "right_tfidf": 0.0028877802151609437,
+      "left_tfidf": 0.00037364250436958054
+    },
+    {
+      "term": "vreemdelingenbeleid",
+      "diff": 0.002474783466537206,
+      "right_tfidf": 0.004326468254883403,
+      "left_tfidf": 0.0018516847883461973
+    },
+    {
+      "term": "statushouders",
+      "diff": 0.0020566860394286095,
+      "right_tfidf": 0.0028435445546928276,
+      "left_tfidf": 0.0007868585152642181
+    },
+    {
+      "term": "veiligheid",
+      "diff": 0.0020479353498792053,
+      "right_tfidf": 0.008055295125654187,
+      "left_tfidf": 0.006007359775774982
+    },
+    {
+      "term": "asielstop",
+      "diff": 0.002021009577662265,
+      "right_tfidf": 0.002021009577662265,
+      "left_tfidf": 0.0
+    },
+    {
+      "term": "stikstof",
+      "diff": 0.0020151689483822125,
+      "right_tfidf": 0.0036985314795571545,
+      "left_tfidf": 0.001683362531174942
+    },
+    {
+      "term": "wetboek",
+      "diff": 0.0020123912463963322,
+      "right_tfidf": 0.004613613582426107,
+      "left_tfidf": 0.002601222336029775
+    },
+    {
+      "term": "strafrecht",
+      "diff": 0.001977219811541617,
+      "right_tfidf": 0.002932516206526633,
+      "left_tfidf": 0.0009552963949850162
+    },
+    {
+      "term": "agrarische",
+      "diff": 0.001909390045472604,
+      "right_tfidf": 0.0026631450469559647,
+      "left_tfidf": 0.0007537550014833608
+    },
+    {
+      "term": "gedwongen",
+      "diff": 0.001795381328377406,
+      "right_tfidf": 0.0023882830883692006,
+      "left_tfidf": 0.0005929017599917945
+    },
+    {
+      "term": "coronamaatregelen",
+      "diff": 0.0017889439956944695,
+      "right_tfidf": 0.0020982659682420926,
+      "left_tfidf": 0.0003093219725476231
+    },
+    {
+      "term": "asiel",
+      "diff": 0.0017269560717394145,
+      "right_tfidf": 0.002896032885858558,
+      "left_tfidf": 0.0011690768141191436
+    },
+    {
+      "term": "begroting",
+      "diff": 0.0016861606105447683,
+      "right_tfidf": 0.002893937917266138,
+      "left_tfidf": 0.0012077773067213698
+    },
+    {
+      "term": "justitie",
+      "diff": 0.0016736056297034121,
+      "right_tfidf": 0.005340110960817776,
+      "left_tfidf": 0.0036665053311143643
+    },
+    {
+      "term": "regeldruk",
+      "diff": 0.001634299245881901,
+      "right_tfidf": 0.0017221464600664762,
+      "left_tfidf": 8.784721418457516e-05
+    },
+    {
+      "term": "europese",
+      "diff": 0.0016194550059820435,
+      "right_tfidf": 0.012660101928205766,
+      "left_tfidf": 0.011040646922223722
+    },
+    {
+      "term": "mkb",
+      "diff": 0.001593916850157352,
+      "right_tfidf": 0.002456043010399644,
+      "left_tfidf": 0.000862126160242292
+    },
+    {
+      "term": "instroom",
+      "diff": 0.0015757844898292715,
+      "right_tfidf": 0.002258608551927495,
+      "left_tfidf": 0.0006828240620982235
+    },
+    {
+      "term": "corona",
+      "diff": 0.0015642362327925978,
+      "right_tfidf": 0.002039496701077217,
+      "left_tfidf": 0.00047526046828461933
+    },
+    {
+      "term": "natura",
+      "diff": 0.0015410578076943103,
+      "right_tfidf": 0.002267554703845169,
+      "left_tfidf": 0.0007264968961508587
+    },
+    {
+      "term": "jbz",
+      "diff": 0.0014856669031578851,
+      "right_tfidf": 0.0024854930840807706,
+      "left_tfidf": 0.0009998261809228855
+    },
+    {
+      "term": "terugkeer",
+      "diff": 0.0014839885911937716,
+      "right_tfidf": 0.0018961353587949204,
+      "left_tfidf": 0.00041214676760114883
+    },
+    {
+      "term": "horeca",
+      "diff": 0.0014669250653227108,
+      "right_tfidf": 0.0016262027099102653,
+      "left_tfidf": 0.00015927764458755454
+    },
+    {
+      "term": "terrassen",
+      "diff": 0.0014564100688148416,
+      "right_tfidf": 0.0014564100688148416,
+      "left_tfidf": 0.0
+    },
+    {
+      "term": "spreidingswet",
+      "diff": 0.001453318438835177,
+      "right_tfidf": 0.0017116272387774412,
+      "left_tfidf": 0.00025830879994226424
+    },
+    {
+      "term": "buitenlucht",
+      "diff": 0.001447838936809374,
+      "right_tfidf": 0.0014854938756013142,
+      "left_tfidf": 3.7654938791940334e-05
+    },
+    {
+      "term": "toekomstvisie",
+      "diff": 0.0014452342007121853,
+      "right_tfidf": 0.0018728127201153616,
+      "left_tfidf": 0.00042757851940317647
+    },
+    {
+      "term": "kerncentrales",
+      "diff": 0.0014117033667126187,
+      "right_tfidf": 0.0015874204128784875,
+      "left_tfidf": 0.00017571704616586872
+    },
+    {
+      "term": "instemmen",
+      "diff": 0.0014075522388711352,
+      "right_tfidf": 0.0017378153859392517,
+      "left_tfidf": 0.00033026314706811644
+    },
+    {
+      "term": "politie",
+      "diff": 0.0014017186095431995,
+      "right_tfidf": 0.0037392397934204965,
+      "left_tfidf": 0.002337521183877297
+    },
+    {
+      "term": "strafbaar",
+      "diff": 0.001399214816885134,
+      "right_tfidf": 0.0015233700600286485,
+      "left_tfidf": 0.0001241552431435146
+    },
+    {
+      "term": "veiliger",
+      "diff": 0.0013917435637725549,
+      "right_tfidf": 0.0018451777114795315,
+      "left_tfidf": 0.00045343414770697665
+    },
+    {
+      "term": "pensioenstelsel",
+      "diff": 0.0013751206507455458,
+      "right_tfidf": 0.0018525658939462872,
+      "left_tfidf": 0.00047744524320074135
+    },
+    {
+      "term": "stikstofbeleid",
+      "diff": 0.0013690641002980942,
+      "right_tfidf": 0.0015036955196541587,
+      "left_tfidf": 0.0001346314193560644
+    },
+    {
+      "term": "visserijraad",
+      "diff": 0.001368604774863244,
+      "right_tfidf": 0.002510883674523926,
+      "left_tfidf": 0.0011422788996606821
+    },
+    {
+      "term": "afzien",
+      "diff": 0.0013660421034534952,
+      "right_tfidf": 0.0024857623824585296,
+      "left_tfidf": 0.0011197202790050344
+    },
+    {
+      "term": "invoeren",
+      "diff": 0.0013655276783388827,
+      "right_tfidf": 0.002732686476464871,
+      "left_tfidf": 0.001367158798125988
+    },
+    {
+      "term": "belang",
+      "diff": 0.0013587675907329386,
+      "right_tfidf": 0.005682309659841887,
+      "left_tfidf": 0.004323542069108948
+    },
+    {
+      "term": "mestbeleid",
+      "diff": 0.00134892559456497,
+      "right_tfidf": 0.001943629058741009,
+      "left_tfidf": 0.000594703464176039
+    },
+    {
+      "term": "asielinstroom",
+      "diff": 0.0013479640849954836,
+      "right_tfidf": 0.0013649479393826741,
+      "left_tfidf": 1.6983854387190533e-05
+    },
+    {
+      "term": "nooit",
+      "diff": 0.0013308048293778282,
+      "right_tfidf": 0.002125383725315249,
+      "left_tfidf": 0.0007945788959374208
+    },
+    {
+      "term": "krijgsmacht",
+      "diff": 0.0013279869184148435,
+      "right_tfidf": 0.0016895758206999694,
+      "left_tfidf": 0.00036158890228512594
+    },
+    {
+      "term": "rondom",
+      "diff": 0.001323620763111042,
+      "right_tfidf": 0.0033617623129662735,
+      "left_tfidf": 0.0020381415498552315
+    },
+    {
+      "term": "graus",
+      "diff": 0.0013107066052195498,
+      "right_tfidf": 0.0017990616492724388,
+      "left_tfidf": 0.000488355044052889
+    }
+  ],
+  "left_keywords": [
+    {
+      "term": "verhoogd",
+      "diff": -0.003800323131539046,
+      "right_tfidf": 0.0019944529709599863,
+      "left_tfidf": 0.0057947761024990324
+    },
+    {
+      "term": "mensen",
+      "diff": -0.0035655147422175622,
+      "right_tfidf": 0.004174565092272633,
+      "left_tfidf": 0.007740079834490195
+    },
+    {
+      "term": "verplichtingenbedrag",
+      "diff": -0.003392238418435396,
+      "right_tfidf": 0.003439198381917264,
+      "left_tfidf": 0.00683143680035266
+    },
+    {
+      "term": "buitenlandse",
+      "diff": -0.003331646880329351,
+      "right_tfidf": 0.005039996681491305,
+      "left_tfidf": 0.008371643561820656
+    },
+    {
+      "term": "uitgavenbedrag",
+      "diff": -0.0032413795795242415,
+      "right_tfidf": 0.003175135604309838,
+      "left_tfidf": 0.006416515183834079
+    },
+    {
+      "term": "middelen",
+      "diff": -0.0032128577047093737,
+      "right_tfidf": 0.003918113284088858,
+      "left_tfidf": 0.007130970988798232
+    },
+    {
+      "term": "volgt",
+      "diff": -0.003211044333596029,
+      "right_tfidf": 0.004963527938967632,
+      "left_tfidf": 0.00817457227256366
+    },
+    {
+      "term": "handel",
+      "diff": -0.0031351749682947813,
+      "right_tfidf": 0.0020248449710976862,
+      "left_tfidf": 0.0051600199393924675
+    },
+    {
+      "term": "discriminatie",
+      "diff": -0.0029952265399205754,
+      "right_tfidf": 0.0012465225378471437,
+      "left_tfidf": 0.004241749077767719
+    },
+    {
+      "term": "internationaal",
+      "diff": -0.002910261753284582,
+      "right_tfidf": 0.0014379635633088776,
+      "left_tfidf": 0.00434822531659346
+    },
+    {
+      "term": "kinderen",
+      "diff": -0.0028024262281300923,
+      "right_tfidf": 0.0019880095830509684,
+      "left_tfidf": 0.004790435811181061
+    },
+    {
+      "term": "begrotingsstaat",
+      "diff": -0.0027305922232981252,
+      "right_tfidf": 0.01021696053656465,
+      "left_tfidf": 0.012947552759862774
+    },
+    {
+      "term": "zorg",
+      "diff": -0.002699517476423169,
+      "right_tfidf": 0.0037527058320764328,
+      "left_tfidf": 0.006452223308499602
+    },
+    {
+      "term": "israël",
+      "diff": -0.0026302057873323374,
+      "right_tfidf": 0.0021627329138823167,
+      "left_tfidf": 0.004792938701214654
+    },
+    {
+      "term": "duurzame",
+      "diff": -0.0024431320983613987,
+      "right_tfidf": 0.0015834157886754927,
+      "left_tfidf": 0.004026547887036891
+    },
+    {
+      "term": "jongeren",
+      "diff": -0.0023955278368396936,
+      "right_tfidf": 0.001520121460929629,
+      "left_tfidf": 0.003915649297769322
+    },
+    {
+      "term": "zaken",
+      "diff": -0.0023541440027530225,
+      "right_tfidf": 0.010212869270589515,
+      "left_tfidf": 0.012567013273342538
+    },
+    {
+      "term": "departementale",
+      "diff": -0.0023050557695713215,
+      "right_tfidf": 0.0029317053925349778,
+      "left_tfidf": 0.005236761162106299
+    },
+    {
+      "term": "ter",
+      "diff": -0.0022656342047127215,
+      "right_tfidf": 0.0065540669504994,
+      "left_tfidf": 0.008819701155212122
+    },
+    {
+      "term": "sociale",
+      "diff": -0.0022597144264270147,
+      "right_tfidf": 0.004775717534517907,
+      "left_tfidf": 0.007035431960944922
+    },
+    {
+      "term": "recht",
+      "diff": -0.0022380331082949194,
+      "right_tfidf": 0.0018926692954098967,
+      "left_tfidf": 0.004130702403704816
+    },
+    {
+      "term": "gaza",
+      "diff": -0.0022266956248005094,
+      "right_tfidf": 0.0005504838982507225,
+      "left_tfidf": 0.002777179523051232
+    },
+    {
+      "term": "humanitaire",
+      "diff": -0.002223820106338663,
+      "right_tfidf": 0.0003263932690958267,
+      "left_tfidf": 0.00255021337543449
+    },
+    {
+      "term": "ontwikkelingssamenwerking",
+      "diff": -0.0021714973939975235,
+      "right_tfidf": 0.0015294434736494004,
+      "left_tfidf": 0.0037009408676469237
+    },
+    {
+      "term": "blijkt",
+      "diff": -0.002162099972073271,
+      "right_tfidf": 0.0017888259757468336,
+      "left_tfidf": 0.003950925947820105
+    },
+    {
+      "term": "juli",
+      "diff": -0.002127473546108199,
+      "right_tfidf": 0.0025150064948918317,
+      "left_tfidf": 0.004642480041000031
+    },
+    {
+      "term": "israëlische",
+      "diff": -0.0021148538540044985,
+      "right_tfidf": 0.0006591390173078768,
+      "left_tfidf": 0.0027739928713123754
+    },
+    {
+      "term": "hulp",
+      "diff": -0.002109698423594897,
+      "right_tfidf": 0.0005740276445887163,
+      "left_tfidf": 0.0026837260681836133
+    },
+    {
+      "term": "welzijn",
+      "diff": -0.002102259922695526,
+      "right_tfidf": 0.0025458341038468615,
+      "left_tfidf": 0.004648094026542387
+    },
+    {
+      "term": "mensenrechten",
+      "diff": -0.0020879003421794156,
+      "right_tfidf": 0.0002880588278919533,
+      "left_tfidf": 0.002375959170071369
+    },
+    {
+      "term": "sport",
+      "diff": -0.0020474366821590304,
+      "right_tfidf": 0.0027172850523000816,
+      "left_tfidf": 0.004764721734459112
+    },
+    {
+      "term": "ingevoegd",
+      "diff": -0.002032072883318145,
+      "right_tfidf": 0.0035425363486034345,
+      "left_tfidf": 0.0055746092319215795
+    },
+    {
+      "term": "fossiele",
+      "diff": -0.002023171223224409,
+      "right_tfidf": 0.00047704455185034443,
+      "left_tfidf": 0.002500215775074753
+    },
+    {
+      "term": "bijdrage",
+      "diff": -0.0020083586864172143,
+      "right_tfidf": 0.0016475000753925512,
+      "left_tfidf": 0.0036558587618097656
+    },
+    {
+      "term": "volgende",
+      "diff": -0.0019917909256765556,
+      "right_tfidf": 0.0060028627510049426,
+      "left_tfidf": 0.007994653676681498
+    },
+    {
+      "term": "volksgezondheid",
+      "diff": -0.0019537232402315205,
+      "right_tfidf": 0.002999130765477296,
+      "left_tfidf": 0.004952854005708817
+    },
+    {
+      "term": "vervanging",
+      "diff": -0.0019511270105074148,
+      "right_tfidf": 0.00460060115604661,
+      "left_tfidf": 0.006551728166554025
+    },
+    {
+      "term": "gezondheid",
+      "diff": -0.0019476146284083432,
+      "right_tfidf": 0.0012372829861680677,
+      "left_tfidf": 0.003184897614576411
+    },
+    {
+      "term": "luidende",
+      "diff": -0.001912494820564106,
+      "right_tfidf": 0.003796060492064439,
+      "left_tfidf": 0.005708555312628545
+    },
+    {
+      "term": "november",
+      "diff": -0.0019033041550907508,
+      "right_tfidf": 0.005447208009912482,
+      "left_tfidf": 0.0073505121650032324
+    },
+    {
+      "term": "toegang",
+      "diff": -0.0018927963171563248,
+      "right_tfidf": 0.0009054318766555786,
+      "left_tfidf": 0.0027982281938119034
+    },
+    {
+      "term": "gedrukt",
+      "diff": -0.0018817856379919006,
+      "right_tfidf": 0.003566293035061206,
+      "left_tfidf": 0.005448078673053107
+    },
+    {
+      "term": "plan",
+      "diff": -0.0018800974626950037,
+      "right_tfidf": 0.002418833384675789,
+      "left_tfidf": 0.004298930847370793
+    },
+    {
+      "term": "koninkrijksrelaties",
+      "diff": -0.0018517550074208552,
+      "right_tfidf": 0.002403165319157252,
+      "left_tfidf": 0.004254920326578107
+    },
+    {
+      "term": "xvi",
+      "diff": -0.001810755339706005,
+      "right_tfidf": 0.0021523713308324575,
+      "left_tfidf": 0.003963126670538462
+    },
+    {
+      "term": "baarle",
+      "diff": -0.001795390634441998,
+      "right_tfidf": 0.00037392993504786753,
+      "left_tfidf": 0.0021693205694898656
+    },
+    {
+      "term": "sociaal",
+      "diff": -0.0017942144426511437,
+      "right_tfidf": 0.0009936799056835185,
+      "left_tfidf": 0.0027878943483346623
+    },
+    {
+      "term": "uitstoot",
+      "diff": -0.0017851137726596065,
+      "right_tfidf": 0.0004700895609280369,
+      "left_tfidf": 0.0022552033335876435
+    },
+    {
+      "term": "oktober",
+      "diff": -0.0017803788561149905,
+      "right_tfidf": 0.003914845876690587,
+      "left_tfidf": 0.005695224732805577
+    },
+    {
+      "term": "ondersteuning",
+      "diff": -0.0017785867125596029,
+      "right_tfidf": 0.001185265736573449,
+      "left_tfidf": 0.002963852449133052
+    }
+  ],
+  "filtered_terms": [
+    "infectieziektenbestrijding",
+    "asielzoekers",
+    "defensie",
+    "ondernemers",
+    "kernenergie",
+    "boeren",
+    "onmiddellijk",
+    "vreemdelingenbeleid",
+    "statushouders",
+    "veiligheid",
+    "asielstop",
+    "stikstof",
+    "wetboek",
+    "strafrecht",
+    "agrarische",
+    "gedwongen",
+    "coronamaatregelen",
+    "asiel",
+    "begroting",
+    "justitie",
+    "regeldruk",
+    "europese",
+    "mkb",
+    "instroom",
+    "corona",
+    "natura",
+    "jbz",
+    "terugkeer",
+    "horeca",
+    "terrassen",
+    "spreidingswet",
+    "buitenlucht",
+    "toekomstvisie",
+    "kerncentrales",
+    "instemmen",
+    "politie",
+    "strafbaar",
+    "veiliger",
+    "pensioenstelsel",
+    "stikstofbeleid",
+    "visserijraad",
+    "afzien",
+    "invoeren",
+    "belang",
+    "mestbeleid",
+    "asielinstroom",
+    "nooit",
+    "krijgsmacht",
+    "rondom",
+    "graus"
+  ],
+  "stats": {
+    "right_motions": 4291,
+    "left_motions": 10766,
+    "unmatched_motions": 13256,
+    "total_motions": 28331
+  }
+}

analysis/right_wing/sentiment_analysis.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""Sentiment analysis pipeline: Dutch sentiment scoring for right-wing motions.
+
+Scores BOTH the original motion text and the layman explanation separately.
+Uses LLM batch calls. Maps outputs to [-1, 1] scale.
+
+Usage:
+    uv run python analysis/right_wing/sentiment_analysis.py --sample 50
+    uv run python analysis/right_wing/sentiment_analysis.py --sample -1
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+from pathlib import Path
+from typing import Any
+
+import duckdb
+
+ROOT = Path(__file__).parent.parent.parent.resolve()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from ai_provider import ProviderError, chat_completion_json_parallel
+from analysis.config import config
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+SENTIMENT_SCHEMA = {
+    "name": "sentiment_score",
+    "strict": True,
+    "schema": {
+        "type": "object",
+        "properties": {
+            "text_score": {
+                "type": "number",
+                "description": "Sentiment of original motion text from -1 (hostile) to 1 (constructive)",
+                "minimum": -1,
+                "maximum": 1,
+            },
+            "text_explanation": {
+                "type": "string",
+                "description": "Why the motion text got this score (Dutch)",
+            },
+            "layman_score": {
+                "type": "number",
+                "description": "Sentiment of layman explanation from -1 (hostile) to 1 (constructive)",
+                "minimum": -1,
+                "maximum": 1,
+            },
+            "layman_explanation": {
+                "type": "string",
+                "description": "Why the layman explanation got this score (Dutch)",
+            },
+        },
+        "required": ["text_score", "text_explanation", "layman_score", "layman_explanation"],
+        "additionalProperties": False,
+    },
+}
+
+PROMPT_TEMPLATE = """Beoordeel de sentiment van de volgende motie op twee manieren:
+
+1) Het ORIGINELE motietekst:
+Titel: {title}
+Tekst: {text}
+
+2) De VEREENVOUDIGDE uitleg:
+{layman}
+
+Geef voor ELKE versie een sentiment score van -1 (zeer negatief, agressief, vijandig) tot 1 (zeer positief, constructief, coöperatief) plus een korte verklaring in het Nederlands."""
+
+
+def _build_prompt(title: str, body_text: str | None, layman: str | None) -> str:
+    text = body_text or title or ""
+    if len(text) > 400:
+        text = text[:400] + "..."
+    layman = layman or "(geen vereenvoudigde uitleg beschikbaar)"
+    if len(layman) > 300:
+        layman = layman[:300] + "..."
+    return PROMPT_TEMPLATE.format(title=title or "", text=text, layman=layman)
+
+
+def _score_batch(
+    motion_ids: list[int],
+    titles: list[str],
+    texts: list[str | None],
+    laymen: list[str | None],
+) -> list[dict[str, Any]]:
+    """Score sentiment for a batch of motions in parallel via LLM."""
+    message_batches = []
+    for title, text, layman in zip(titles, texts, laymen):
+        prompt = _build_prompt(title, text, layman)
+        message_batches.append([{"role": "user", "content": prompt}])
+
+    try:
+        results = chat_completion_json_parallel(
+            message_batches,
+            model=config.QWEN_MODEL,
+            json_schema=SENTIMENT_SCHEMA,
+            max_workers=5,
+        )
+    except ProviderError as exc:
+        logger.error("Batch API call failed: %s", exc)
+        return [{
+            "text_score": None, "text_explanation": None,
+            "layman_score": None, "layman_explanation": None,
+            "error": str(exc),
+        }] * len(motion_ids)
+
+    validated = []
+    for res in results:
+        if not isinstance(res, dict):
+            validated.append({
+                "text_score": None, "text_explanation": None,
+                "layman_score": None, "layman_explanation": None,
+                "error": "non-dict response",
+            })
+            continue
+        ts = res.get("text_score")
+        te = res.get("text_explanation")
+        ls = res.get("layman_score")
+        le = res.get("layman_explanation")
+        if not isinstance(ts, (int, float)) or ts < -1 or ts > 1:
+            validated.append({
+                "text_score": None, "text_explanation": None,
+                "layman_score": None, "layman_explanation": None,
+                "error": f"invalid text_score: {ts}",
+            })
+            continue
+        if not isinstance(ls, (int, float)) or ls < -1 or ls > 1:
+            validated.append({
+                "text_score": None, "text_explanation": None,
+                "layman_score": None, "layman_explanation": None,
+                "error": f"invalid layman_score: {ls}",
+            })
+            continue
+        validated.append({
+            "text_score": float(ts), "text_explanation": te,
+            "layman_score": float(ls), "layman_explanation": le,
+            "error": None,
+        })
+    return validated
+
+
+def analyze_sentiment(
+    db_path: str = "data/motions.db",
+    sample_size: int = 50,
+    batch_size: int = 10,
+) -> dict[str, Any]:
+    """Analyze sentiment of right-wing motions and aggregate by year."""
+    db = Path(db_path)
+    if not db.exists():
+        raise FileNotFoundError(f"Database not found: {db}")
+
+    con = duckdb.connect(str(db))
+    try:
+        tables = {t[0] for t in con.execute("SHOW TABLES").fetchall()}
+        if "right_wing_motions" not in tables:
+            raise RuntimeError("Run classify_motions.py first.")
+
+        limit_clause = "" if sample_size < 0 else f"LIMIT {sample_size}"
+        rows = con.execute(
+            f"""
+            SELECT r.motion_id, r.year, m.title, m.body_text, m.layman_explanation
+            FROM right_wing_motions r
+            JOIN motions m ON r.motion_id = m.id
+            WHERE r.classified = TRUE
+            ORDER BY RANDOM()
+            {limit_clause}
+            """
+        ).fetchall()
+
+        if not rows:
+            logger.warning("No classified right-wing motions found.")
+            return {"scored": 0, "failed": 0}
+
+        # Resume support: only create table if missing, skip already-scored motions
+        con.execute(
+            """
+            CREATE TABLE IF NOT EXISTS sentiment_scores (
+                motion_id INTEGER PRIMARY KEY,
+                year INTEGER,
+                text_score DOUBLE,
+                text_explanation VARCHAR,
+                layman_score DOUBLE,
+                layman_explanation VARCHAR,
+                error VARCHAR
+            )
+            """
+        )
+        already_scored = {
+            r[0] for r in con.execute("SELECT motion_id FROM sentiment_scores WHERE error IS NULL").fetchall()
+        }
+        rows = [r for r in rows if r[0] not in already_scored]
+
+        logger.info("Scoring sentiment for %d motions in batches of %d...", len(rows), batch_size)
+
+        scored = 0
+        failed = 0
+
+        for i in range(0, len(rows), batch_size):
+            batch = rows[i : i + batch_size]
+            motion_ids = [r[0] for r in batch]
+            years = [r[1] for r in batch]
+            titles = [r[2] for r in batch]
+            texts = [r[3] for r in batch]
+            laymen = [r[4] for r in batch]
+
+            logger.info("Batch %d/%d (%d motions)", i // batch_size + 1, (len(rows) - 1) // batch_size + 1, len(batch))
+            results = _score_batch(motion_ids, titles, texts, laymen)
+
+            for mid, year, res in zip(motion_ids, years, results):
+                con.execute(
+                    """
+                    INSERT OR REPLACE INTO sentiment_scores
+                    (motion_id, year, text_score, text_explanation, layman_score, layman_explanation, error)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        mid, year,
+                        res.get("text_score"), res.get("text_explanation"),
+                        res.get("layman_score"), res.get("layman_explanation"),
+                        res.get("error"),
+                    ),
+                )
+                if res.get("error") is None:
+                    scored += 1
+                else:
+                    failed += 1
+
+        con.commit()
+
+        # Add sentiment columns to yearly summary if not present
+        cols = {c[1] for c in con.execute("PRAGMA table_info(yearly_right_wing_summary)").fetchall()}
+        if "avg_sentiment" not in cols:
+            con.execute("ALTER TABLE yearly_right_wing_summary ADD COLUMN avg_sentiment DOUBLE")
+        if "sentiment_std" not in cols:
+            con.execute("ALTER TABLE yearly_right_wing_summary ADD COLUMN sentiment_std DOUBLE")
+        if "pct_strongly_negative" not in cols:
+            con.execute("ALTER TABLE yearly_right_wing_summary ADD COLUMN pct_strongly_negative DOUBLE")
+
+        con.execute(
+            """
+            UPDATE yearly_right_wing_summary
+            SET avg_sentiment = (
+                SELECT AVG(s.text_score)
+                FROM sentiment_scores s
+                WHERE s.year = yearly_right_wing_summary.year
+                  AND s.text_score IS NOT NULL
+            ),
+            sentiment_std = (
+                SELECT STDDEV(s.text_score)
+                FROM sentiment_scores s
+                WHERE s.year = yearly_right_wing_summary.year
+                  AND s.text_score IS NOT NULL
+            ),
+            pct_strongly_negative = (
+                SELECT COUNT(CASE WHEN s.text_score < -0.5 THEN 1 END) * 100.0 / NULLIF(COUNT(*), 0)
+                FROM sentiment_scores s
+                WHERE s.year = yearly_right_wing_summary.year
+                  AND s.text_score IS NOT NULL
+            )
+            """
+        )
+        con.commit()
+
+        logger.info("Scored %d motions, %d failures", scored, failed)
+        return {"scored": scored, "failed": failed, "sample_size": len(rows)}
+    finally:
+        con.close()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Sentiment analysis for right-wing motions")
+    parser.add_argument("--db", default="data/motions.db")
+    parser.add_argument("--sample", type=int, default=50, help="Number of motions to score (-1 for all)")
+    parser.add_argument("--batch-size", type=int, default=10)
+    args = parser.parse_args()
+
+    result = analyze_sentiment(db_path=args.db, sample_size=args.sample, batch_size=args.batch_size)
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/success_correlation.py

@@ -0,0 +1,458 @@
+#!/usr/bin/env python3
+"""U6: Test whether motions with high centrist support actually passed at higher rates.
+
+Computes pass_rate for right-wing motions by centrist_support_strict quartile,
+tests for a monotonic relationship (Cochran-Armitage trend test), stratifies by
+period and government/opposition, and computes the success premium.
+
+Usage:
+    uv run python -m analysis.right_wing.success_correlation
+
+Output:
+    reports/overton_window/success_correlation.md
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+import duckdb
+import numpy as np
+from scipy.stats import chi2
+
+from analysis.right_wing.common import (
+    BREAK_YEAR, COALITION, DB_PATH, REPORTS_DIR,
+    build_party_name_map, parse_lead_submitter,
+)
+from analysis.config import CANONICAL_RIGHT
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+def motion_passed(voting: dict | None, winning_margin: float | None = None) -> bool | None:
+    if voting is None:
+        voting = {}
+    if winning_margin is not None:
+        return winning_margin > 0
+    voor = sum(1 for v in voting.values() if v == "voor")
+    tegen = sum(1 for v in voting.values() if v == "tegen")
+    if voor + tegen == 0:
+        return None
+    return voor > tegen
+
+
+def cochran_armitage_trend_test(
+    counts: np.ndarray, totals: np.ndarray, scores: np.ndarray | None = None
+) -> dict[str, float]:
+    """Cochran-Armitage trend test for monotonic relationship.
+
+    counts[i] = number of successes in bin i
+    totals[i] = total observations in bin i
+    scores[i] = trend score for bin i (default: 1, 2, 3, ..., k)
+    """
+    k = len(counts)
+    if scores is None:
+        scores = np.arange(1, k + 1, dtype=float)
+
+    n = totals.sum()
+    x = counts.sum()
+    p_hat = x / n if n > 0 else 0.0
+
+    expected = totals * p_hat
+    numerator = np.sum(scores * (counts - expected))
+    denominator = p_hat * (1 - p_hat) * (np.sum(totals * scores**2) - np.sum(totals * scores) ** 2 / n)
+
+    if denominator <= 0 or p_hat in (0.0, 1.0):
+        return {"statistic": 0.0, "p_value": 1.0, "df": 1}
+
+    chi2_stat = numerator**2 / denominator
+    p_value = 1.0 - chi2.cdf(chi2_stat, 1)
+    return {"statistic": chi2_stat, "p_value": p_value, "df": 1}
+
+
+def quartile_bin(cs: float) -> int:
+    """Map centrist_support_strict to quartile bin 0-3."""
+    if cs <= 0.25:
+        return 0
+    elif cs <= 0.50:
+        return 1
+    elif cs <= 0.75:
+        return 2
+    else:
+        return 3
+
+
+QUARTILE_LABELS = [
+    "Q1 [0.00\u20130.25]",
+    "Q2 (0.25\u20130.50]",
+    "Q3 (0.50\u20130.75]",
+    "Q4 (0.75\u20131.00]",
+]
+
+
+def collect_motion_data(
+    con: duckdb.DuckDBPyConnection, name_party_map: dict[str, str]
+) -> list[dict[str, Any]]:
+    rows = con.execute("""
+        SELECT
+            r.motion_id,
+            r.year,
+            r.title,
+            r.centrist_support_strict,
+            m.voting_results,
+            m.winning_margin
+        FROM right_wing_motions r
+        JOIN motions m ON r.motion_id = m.id
+        WHERE r.classified = TRUE
+          AND r.year IS NOT NULL
+          AND r.centrist_support_strict IS NOT NULL
+    """).fetchall()
+
+    motions: list[dict[str, Any]] = []
+    for mid, year, title, cs, vr_json, wm in rows:
+        voting = json.loads(vr_json) if isinstance(vr_json, str) else (vr_json or {})
+        passed = motion_passed(voting, wm)
+
+        submitter_name, submitter_party = parse_lead_submitter(title, name_party_map)
+        coalition = COALITION.get(int(year), set())
+        motion_type = None
+        if submitter_party is not None:
+            motion_type = "government" if submitter_party in coalition else "opposition"
+
+        motions.append({
+            "motion_id": mid,
+            "year": int(year),
+            "centrist_support_strict": float(cs),
+            "passed": passed,
+            "submitter_party": submitter_party,
+            "motion_type": motion_type,
+            "period": "post-2024" if int(year) >= BREAK_YEAR else "pre-2024",
+        })
+
+    return motions
+
+
+def compute_quartile_pass_rates(
+    motions: list[dict], filter_fn=None
+) -> dict[str, dict[int, dict[str, Any]]]:
+    """Compute pass_rate by centrist_support quartile.
+
+    filter_fn: optional (motion) -> bool filter.
+    Returns dict with keys: 'all', 'pre-2024', 'post-2024', 'government', 'opposition'
+    when no filter is applied. When filter_fn is given, returns a single key 'filtered'.
+    """
+    if filter_fn is None:
+        strata = {
+            "all": lambda m: True,
+            "pre-2024": lambda m: m["period"] == "pre-2024",
+            "post-2024": lambda m: m["period"] == "post-2024",
+            "government": lambda m: m["motion_type"] == "government",
+            "opposition": lambda m: m["motion_type"] == "opposition",
+        }
+    else:
+        strata = {"filtered": filter_fn}
+
+    result: dict[str, dict[int, dict]] = {}
+    for label, fn in strata.items():
+        bins: dict[int, dict] = {q: {"passed": 0, "total": 0, "n_determined": 0}
+                                  for q in range(4)}
+        for m in motions:
+            if not fn(m):
+                continue
+            q = quartile_bin(m["centrist_support_strict"])
+            bins[q]["total"] += 1
+            if m["passed"] is not None:
+                bins[q]["n_determined"] += 1
+                if m["passed"]:
+                    bins[q]["passed"] += 1
+
+        for q in range(4):
+            d = bins[q]
+            d["pass_rate"] = d["passed"] / d["n_determined"] if d["n_determined"] > 0 else float("nan")
+            d["undetermined"] = d["total"] - d["n_determined"]
+
+        result[label] = bins
+
+    return result
+
+
+def format_pass_rate_table(
+    strata: dict[str, dict[int, dict]], label_map: dict[str, str] | None = None
+) -> str:
+    if label_map is None:
+        label_map = {k: k for k in strata}
+
+    lines = ["| Stratum | " + " | ".join(QUARTILE_LABELS) + " | N total | Trend \u03c7\u00b2 | p-value |",
+              "|---------|" + "|".join(["-" * len(lb) for lb in QUARTILE_LABELS]) + "|---------|-----------|---------|"]
+
+    for key, bins in strata.items():
+        prs = []
+        for q in range(4):
+            rate = bins[q]["pass_rate"]
+            nd = bins[q]["n_determined"]
+            if np.isnan(rate):
+                prs.append(f"N/A (n={nd})")
+            else:
+                prs.append(f"{rate:.1%} (n={nd})")
+        total = sum(bins[q]["total"] for q in range(4))
+        nd_total = sum(bins[q]["n_determined"] for q in range(4))
+
+        counts = np.array([bins[q]["passed"] for q in range(4)], dtype=float)
+        totals = np.array([bins[q]["n_determined"] for q in range(4)], dtype=float)
+        trend = cochran_armitage_trend_test(counts, totals)
+
+        label = label_map.get(key, key)
+        if trend["p_value"] < 0.001:
+            p_str = "<0.001"
+        else:
+            p_str = f"{trend['p_value']:.3f}"
+
+        lines.append(
+            f"| {label} | " + " | ".join(prs) + f" | {nd_total} | {trend['statistic']:.2f} | {p_str} |"
+        )
+
+    return "\n".join(lines)
+
+
+def compute_success_premium(
+    strata: dict[str, dict[int, dict]]
+) -> dict[str, float]:
+    premiums: dict[str, float] = {}
+    for key, bins in strata.items():
+        low_rate = bins[0]["pass_rate"]  # Q1
+        high_rate = bins[3]["pass_rate"]  # Q4
+        if not np.isnan(low_rate) and not np.isnan(high_rate):
+            premiums[key] = high_rate - low_rate
+        else:
+            premiums[key] = float("nan")
+    return premiums
+
+
+def generate_report(
+    all_strata: dict[str, dict[int, dict]],
+    premium: dict[str, float],
+    n_total: int,
+    n_with_outcome: int,
+    n_passed: int,
+    overall_pass_rate: float,
+    n_government: int,
+    n_opposition: int,
+    n_unknown_type: int,
+) -> str:
+    lines = [
+        "# Motion Success Correlation Analysis",
+        "",
+        "**Goal:** Test whether motions with high centrist support actually passed at higher rates,",
+        "validating that centrist support translates to legislative success.",
+        "",
+        f"**Analysis period:** 2016\u20132026",
+        f"**Total right-wing motions:** {n_total}",
+        f"**Motions with determinable outcome:** {n_with_outcome}",
+        f"**Motions passed:** {n_passed} ({overall_pass_rate:.1%})",
+        f"**Government motions:** {n_government}  \u00b7  **Opposition motions:** {n_opposition}  \u00b7  **Unknown type:** {n_unknown_type}",
+        "",
+        "---",
+        "",
+        "## 1. Pass Rate by Centrist Support Quartile",
+        "",
+        "Centrist support (strict) is the fraction of centrist parties that voted 'voor'.",
+        "Quartile bins are: [0-0.25], (0.25-0.50], (0.50-0.75], (0.75-1.0].",
+        "",
+        format_pass_rate_table(all_strata),
+        "",
+        "**Cochran-Armitage trend test:** Tests for a monotonic trend in pass rates across",
+        "ordered quartile bins. A significant result (p < 0.05) indicates that pass rates",
+        "increase or decrease systematically with centrist support level.",
+        "",
+        "---",
+        "",
+        "## 2. Success Premium",
+        "",
+        'The "success premium" is the difference in pass_rate between the highest centrist',
+        "support quartile (Q4) and the lowest (Q1): pass_rate(Q4) - pass_rate(Q1).",
+        "",
+    ]
+
+    lines.append("| Stratum | Q1 Pass Rate | Q4 Pass Rate | Premium |")
+    lines.append("|---------|-------------|-------------|---------|")
+    for key in ["all", "pre-2024", "post-2024", "government", "opposition"]:
+        if key in all_strata:
+            q1 = all_strata[key][0]["pass_rate"]
+            q4 = all_strata[key][3]["pass_rate"]
+            p = premium[key]
+            q1s = f"{q1:.1%}" if not np.isnan(q1) else "N/A"
+            q4s = f"{q4:.1%}" if not np.isnan(q4) else "N/A"
+            ps = f"{p:+.1%}" if not np.isnan(p) else "N/A"
+            lines.append(f"| {key} | {q1s} | {q4s} | {ps} |")
+
+    lines += [
+        "",
+        "Positive premium \u2192 higher centrist support correlates with higher pass rate.",
+        "Negative premium \u2192 higher centrist support correlates with lower pass rate.",
+        "",
+        "---",
+        "",
+        "## 3. Period Stratification (Pre vs Post-2024)",
+        "",
+        "Pre-2024: 2016\u20132023 (Rutte cabinets II\u2013IV).",
+        "Post-2024: 2024\u20132026 (Schoof cabinet, PVV in coalition).",
+        "",
+        "The post-2024 period has far more right-wing motions (volume surge).",
+        "If the success premium differs between periods, the structural break",
+        "affected not just centrist willingness to support but also motion outcomes.",
+        "",
+        "---",
+        "",
+        "## 4. Government vs Opposition Control",
+        "",
+        "Government motions come from coalition party members and generally have higher",
+        "baseline pass rates. Opposition motions are the true test: if high centrist support",
+        "predicts passage for opposition motions, centrist backing is decisive.",
+        "",
+        "Motion type is determined by parsing the lead submitter from the title prefix",
+        "(e.g., 'Motie van het lid Wilders over ...').",
+        "",
+        "---",
+        "",
+        "## 5. Interpretation",
+        "",
+    ]
+
+    all_bins = all_strata["all"]
+    all_counts = np.array([all_bins[q]["passed"] for q in range(4)], dtype=float)
+    all_totals_arr = np.array([all_bins[q]["n_determined"] for q in range(4)], dtype=float)
+    trend = cochran_armitage_trend_test(all_counts, all_totals_arr)
+
+    if trend["p_value"] < 0.05:
+        direction = "positive" if premium.get("all", 0) > 0 else "negative"
+        lines.append(
+            f"The Cochran-Armitage trend test is significant (\u03c7\u00b2={trend['statistic']:.2f}, "
+            f"p={trend['p_value']:.3f}), indicating a {direction} monotonic relationship "
+            f"between centrist support and pass rate. The success premium is "
+            f"{premium.get('all', 0):+.1%}."
+        )
+    else:
+        lines.append(
+            f"The Cochran-Armitage trend test is not significant (\u03c7\u00b2={trend['statistic']:.2f}, "
+            f"p={trend['p_value']:.3f}). There is no evidence of a monotonic relationship "
+            f"between centrist support and pass rate. This is consistent with the observation "
+            f"that virtually all motions pass in the Dutch parliament (ceiling effect)."
+        )
+
+    if "opposition" in all_strata:
+        opp_bins = all_strata["opposition"]
+        opp_counts = np.array([opp_bins[q]["passed"] for q in range(4)], dtype=float)
+        opp_totals_arr = np.array([opp_bins[q]["n_determined"] for q in range(4)], dtype=float)
+        opp_trend = cochran_armitage_trend_test(opp_counts, opp_totals_arr)
+        lines.append("")
+        lines.append(
+            f"For opposition motions specifically, the trend test "
+            f"is {'significant' if opp_trend['p_value'] < 0.05 else 'not significant'} "
+            f"(\u03c7\u00b2={opp_trend['statistic']:.2f}, p={opp_trend['p_value']:.3f})."
+        )
+
+    paths = [p for p in all_strata if p.startswith("pre") or p.startswith("post")]
+    lines.append("")
+    lines.append("### Period Comparison")
+    for p in paths:
+        bins = all_strata[p]
+        p_counts = np.array([bins[q]["passed"] for q in range(4)], dtype=float)
+        p_totals_arr = np.array([bins[q]["n_determined"] for q in range(4)], dtype=float)
+        p_trend = cochran_armitage_trend_test(p_counts, p_totals_arr)
+        n = int(p_totals_arr.sum())
+        lines.append(
+            f"- **{p}** (n={n}): \u03c7\u00b2={p_trend['statistic']:.2f}, "
+            f"p={p_trend['p_value']:.3f}, premium={premium.get(p, float('nan')):+.1%}"
+        )
+
+    lines += [
+        "",
+        "---",
+        "",
+        "## 6. Limitations",
+        "",
+        "- **Ceiling effect:** Dutch parliamentary motions pass at very high rates (>95%),",
+        "  leaving little variance to detect correlation with centrist support.",
+        "- **Undetermined outcomes:** Some motions had equal votes or no voting data,",
+        "  reducing sample size (excluded from pass rate calculation).",
+        "- **Submitter parsing:** Lead submitter party identification from title prefixes",
+        "  may misclassify some multi-submitter motions.",
+        "- **Coalition coding:** 2024 is ambiguous (Rutte IV until July, Schoof thereafter).",
+        "- **Causality direction:** Correlation does not imply causation. High centrist support",
+        "  could reflect motions that were already likely to pass (centrists voting with the",
+        "  majority), rather than centrist support causing passage.",
+        "",
+        "---",
+        "",
+        "*Report generated by `analysis/right_wing/success_correlation.py`*",
+    ]
+
+    report_path = REPORTS_DIR / "success_correlation.md"
+    with open(report_path, "w") as f:
+        f.write("\n".join(lines))
+    logger.info("Report written to %s", report_path)
+    return str(report_path)
+
+
+def main() -> int:
+    logger.info("Connecting to database: %s", DB_PATH)
+    con = duckdb.connect(DB_PATH, read_only=True)
+
+    logger.info("Building party name map...")
+    name_party_map = build_party_name_map(con)
+
+    logger.info("Collecting motion data...")
+    motions = collect_motion_data(con, name_party_map)
+    con.close()
+
+    n_total = len(motions)
+    n_with_outcome = sum(1 for m in motions if m["passed"] is not None)
+    n_passed = sum(1 for m in motions if m["passed"] is True)
+    overall_pass_rate = n_passed / n_with_outcome if n_with_outcome > 0 else 0.0
+
+    n_government = sum(1 for m in motions if m["motion_type"] == "government")
+    n_opposition = sum(1 for m in motions if m["motion_type"] == "opposition")
+    n_unknown_type = sum(1 for m in motions if m["motion_type"] is None)
+
+    logger.info(
+        "Total: %d motions, %d with outcome, %d passed (%.1f%%), gov=%d opp=%d unknown=%d",
+        n_total, n_with_outcome, n_passed, overall_pass_rate * 100,
+        n_government, n_opposition, n_unknown_type,
+    )
+
+    all_strata = compute_quartile_pass_rates(motions)
+    premium = compute_success_premium(all_strata)
+
+    for key in ["all", "pre-2024", "post-2024", "government", "opposition"]:
+        if key in premium:
+            logger.info("Success premium (%s): %+.1f%%", key, premium[key] * 100)
+
+    report_path = generate_report(
+        all_strata=all_strata,
+        premium=premium,
+        n_total=n_total,
+        n_with_outcome=n_with_outcome,
+        n_passed=n_passed,
+        overall_pass_rate=overall_pass_rate,
+        n_government=n_government,
+        n_opposition=n_opposition,
+        n_unknown_type=n_unknown_type,
+    )
+
+    print(f"\nReport: {report_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/svd_trajectory_viz.py

@@ -0,0 +1,365 @@
+#!/usr/bin/env python3
+"""Visualize SVD spatial drift over 10 annual windows.
+
+Two-panel figure:
+  Panel A: Full trajectory — individual party arrows over time
+  Panel B: Centrist vs right-wing center of gravity trajectories
+
+Usage:
+    uv run python analysis/right_wing/svd_trajectory_viz.py
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+
+matplotlib.use("Agg")
+
+from analysis.right_wing.common import ROOT, DB_PATH, REPORTS_DIR
+
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from analysis.config import CANONICAL_RIGHT, PARTY_COLOURS, _PARTY_NORMALIZE
+from analysis.explorer_data import (
+    get_uniform_dim_windows,
+    load_party_scores_all_windows_aligned,
+)
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger("svd_trajectory_viz")
+
+CANONICAL_CENTRIST = frozenset(
+    {"VVD", "D66", "CDA", "NSC", "BBB", "CU", "ChristenUnie"}
+)
+
+OUTPUT_PATH = str(REPORTS_DIR / "svd_trajectory_figure.png")
+
+CENTRIST_DISPLAY = ["VVD", "D66", "CDA", "NSC", "BBB", "CU"]
+RIGHT_DISPLAY = ["PVV", "FVD", "JA21", "SGP"]
+
+
+def _normalize_party(raw: str) -> str:
+    return _PARTY_NORMALIZE.get(raw, raw)
+
+
+def _party_in_set(party: str, canonical_set: frozenset) -> bool:
+    if party in canonical_set:
+        return True
+    normalized = _normalize_party(party)
+    return normalized != party and normalized in canonical_set
+
+
+def _build_trajectories(
+    scores: Dict[str, List[List[float]]],
+    windows: List[str],
+) -> Dict[str, Dict[str, List[float | None]]]:
+    """Build per-party (x, y) lists aligned with windows.
+
+    Returns {party: {"x": [...], "y": [...], "windows": [...]}}
+    where each list has one entry per window (None if party missing).
+    """
+    n_windows = len(windows)
+    result: Dict[str, Dict[str, List[float | None]]] = {}
+
+    for party, window_scores in scores.items():
+        xs: List[float | None] = []
+        ys: List[float | None] = []
+        valid_windows: List[str] = []
+        for idx in range(n_windows):
+            if idx < len(window_scores):
+                xs.append(window_scores[idx][0])
+                ys.append(window_scores[idx][1])
+                valid_windows.append(windows[idx])
+            else:
+                xs.append(None)
+                ys.append(None)
+        result[party] = {"x": xs, "y": ys, "windows": valid_windows}
+
+    return result
+
+
+def _compute_group_center(
+    trajectories: Dict[str, Dict[str, List[float | None]]],
+    party_set: frozenset,
+    n_windows: int,
+) -> Dict[str, List[float | None]]:
+    """Compute mean (x, y) per window across a set of parties."""
+    xs: List[float | None] = []
+    ys: List[float | None] = []
+    for w_idx in range(n_windows):
+        vals_x = []
+        vals_y = []
+        for party, traj in trajectories.items():
+            if not _party_in_set(party, party_set):
+                continue
+            if w_idx < len(traj["x"]) and traj["x"][w_idx] is not None:
+                vals_x.append(traj["x"][w_idx])
+                vals_y.append(traj["y"][w_idx])
+        if vals_x:
+            xs.append(float(np.mean(vals_x)))
+            ys.append(float(np.mean(vals_y)))
+        else:
+            xs.append(None)
+            ys.append(None)
+    return {"x": xs, "y": ys}
+
+
+def _plot_party_trajectory(
+    ax: plt.Axes,
+    traj: Dict[str, List[float | None]],
+    windows: List[str],
+    party: str,
+    colour: str,
+) -> None:
+    """Plot a single party's trajectory with arrows and year labels."""
+    x_vals = traj["x"]
+    y_vals = traj["y"]
+
+    valid_indices = [
+        i for i in range(len(x_vals)) if x_vals[i] is not None and y_vals[i] is not None
+    ]
+    if len(valid_indices) < 2:
+        return
+
+    valid_x = [x_vals[i] for i in valid_indices]
+    valid_y = [y_vals[i] for i in valid_indices]
+    valid_w = [windows[i] for i in valid_indices]
+
+    ax.plot(valid_x, valid_y, "-", color=colour, linewidth=1.2, alpha=0.5, zorder=1)
+
+    for i in range(len(valid_x) - 1):
+        ax.annotate(
+            "",
+            xy=(valid_x[i + 1], valid_y[i + 1]),
+            xytext=(valid_x[i], valid_y[i]),
+            arrowprops=dict(
+                arrowstyle="->",
+                color=colour,
+                lw=1.0,
+                alpha=0.5,
+                shrinkA=4,
+                shrinkB=4,
+            ),
+            zorder=2,
+        )
+
+    ax.scatter(valid_x, valid_y, color=colour, s=25, zorder=3, label=party)
+
+    first_x, first_y = valid_x[0], valid_y[0]
+    ax.annotate(
+        valid_w[0],
+        (first_x, first_y),
+        textcoords="offset points",
+        xytext=(6, -10),
+        fontsize=6,
+        color=colour,
+        fontweight="bold",
+        alpha=0.8,
+    )
+
+    last_x, last_y = valid_x[-1], valid_y[-1]
+    ax.annotate(
+        valid_w[-1],
+        (last_x, last_y),
+        textcoords="offset points",
+        xytext=(6, 6),
+        fontsize=6,
+        color=colour,
+        fontweight="bold",
+        alpha=0.8,
+    )
+
+
+def main() -> None:
+    os.makedirs(str(REPORTS_DIR), exist_ok=True)
+
+    logger.info("Loading aligned party positions...")
+    windows = get_uniform_dim_windows(DB_PATH)
+    if not windows:
+        logger.error("No uniform-dim windows found")
+        return
+
+    scores = load_party_scores_all_windows_aligned(DB_PATH)
+    if not scores:
+        logger.error("No aligned party scores loaded")
+        return
+
+    logger.info("Windows: %s", windows)
+    logger.info("Parties: %s", sorted(scores.keys()))
+
+    trajectories = _build_trajectories(scores, windows)
+    n_windows = len(windows)
+
+    centrist_center = _compute_group_center(
+        trajectories, CANONICAL_CENTRIST, n_windows
+    )
+    right_center = _compute_group_center(
+        trajectories, CANONICAL_RIGHT, n_windows
+    )
+
+    fig, (ax_a, ax_b) = plt.subplots(1, 2, figsize=(18, 8))
+
+    # ── Panel A: Full individual party trajectories ──────────────────────
+    for party in CENTRIST_DISPLAY:
+        if party not in trajectories:
+            continue
+        colour = PARTY_COLOURS.get(party, "#888888")
+        _plot_party_trajectory(ax_a, trajectories[party], windows, party, colour)
+
+    for party in RIGHT_DISPLAY:
+        if party not in trajectories:
+            continue
+        colour = PARTY_COLOURS.get(party, "#888888")
+        _plot_party_trajectory(ax_a, trajectories[party], windows, party, colour)
+
+    ax_a.axhline(0, color="#CCCCCC", linewidth=0.5, linestyle="-")
+    ax_a.axvline(0, color="#CCCCCC", linewidth=0.5, linestyle="-")
+    ax_a.set_xlabel("PCA Axis 1 (Procrustes-aligned)")
+    ax_a.set_ylabel("PCA Axis 2 (Procrustes-aligned)")
+    ax_a.set_title("Panel A: Party Trajectories (All Windows)", fontsize=11)
+    ax_a.set_aspect("equal", adjustable="datalim")
+    ax_a.grid(True, alpha=0.2)
+    ax_a.legend(loc="upper left", fontsize=7, framealpha=0.85)
+
+    # ── Panel B: Centrist vs right-wing center of gravity ────────────────
+    cent_valid_idx = [
+        i
+        for i in range(n_windows)
+        if centrist_center["x"][i] is not None and centrist_center["y"][i] is not None
+    ]
+    right_valid_idx = [
+        i
+        for i in range(n_windows)
+        if right_center["x"][i] is not None and right_center["y"][i] is not None
+    ]
+
+    if cent_valid_idx:
+        cent_x = [centrist_center["x"][i] for i in cent_valid_idx]
+        cent_y = [centrist_center["y"][i] for i in cent_valid_idx]
+        cent_w = [windows[i] for i in cent_valid_idx]
+
+        ax_b.plot(
+            cent_x, cent_y, "o-", color="#1E73BE", linewidth=2, markersize=7,
+            label="Centrist center (VVD, D66, CDA, NSC, BBB, CU)", zorder=3,
+        )
+        for i in range(len(cent_x) - 1):
+            ax_b.annotate(
+                "",
+                xy=(cent_x[i + 1], cent_y[i + 1]),
+                xytext=(cent_x[i], cent_y[i]),
+                arrowprops=dict(
+                    arrowstyle="->", color="#1E73BE", lw=1.5, alpha=0.6,
+                ),
+                zorder=2,
+            )
+        for i, label in enumerate(cent_w):
+            ax_b.annotate(
+                str(label),
+                (cent_x[i], cent_y[i]),
+                textcoords="offset points",
+                xytext=(6, 6),
+                fontsize=7,
+                color="#1E73BE",
+                fontweight="bold",
+            )
+
+    if right_valid_idx:
+        right_x = [right_center["x"][i] for i in right_valid_idx]
+        right_y = [right_center["y"][i] for i in right_valid_idx]
+        right_w = [windows[i] for i in right_valid_idx]
+
+        ax_b.plot(
+            right_x, right_y, "s--", color="#6A1B9A", linewidth=1.5,
+            markersize=6, alpha=0.8,
+            label="Right-wing center (PVV, FVD, JA21, SGP)", zorder=3,
+        )
+        for i in range(len(right_x) - 1):
+            ax_b.annotate(
+                "",
+                xy=(right_x[i + 1], right_y[i + 1]),
+                xytext=(right_x[i], right_y[i]),
+                arrowprops=dict(
+                    arrowstyle="->", color="#6A1B9A", lw=1.2, alpha=0.5,
+                ),
+                zorder=2,
+            )
+        for i, label in enumerate(right_w):
+            ax_b.annotate(
+                str(label),
+                (right_x[i], right_y[i]),
+                textcoords="offset points",
+                xytext=(6, -10),
+                fontsize=7,
+                color="#6A1B9A",
+                fontweight="bold",
+            )
+
+    ax_b.axhline(0, color="#CCCCCC", linewidth=0.5, linestyle="-")
+    ax_b.axvline(0, color="#CCCCCC", linewidth=0.5, linestyle="-")
+    ax_b.set_xlabel("PCA Axis 1 (Procrustes-aligned)")
+    ax_b.set_ylabel("PCA Axis 2 (Procrustes-aligned)")
+    ax_b.set_title("Panel B: Group Center of Gravity Trajectories", fontsize=11)
+    ax_b.set_aspect("equal", adjustable="datalim")
+    ax_b.grid(True, alpha=0.2)
+    ax_b.legend(loc="upper left", fontsize=7, framealpha=0.85)
+
+    fig.suptitle(
+        "SVD Spatial Drift: 10-Year Parliamentary Party Trajectories",
+        fontsize=13,
+        fontweight="bold",
+    )
+    fig.tight_layout(rect=[0, 0, 1, 0.96])
+    fig.savefig(OUTPUT_PATH, dpi=150, bbox_inches="tight", facecolor="white")
+    plt.close(fig)
+
+    logger.info("Figure saved to %s", OUTPUT_PATH)
+
+    cent_start = (
+        (centrist_center["x"][cent_valid_idx[0]], centrist_center["y"][cent_valid_idx[0]])
+        if cent_valid_idx
+        else (None, None)
+    )
+    cent_end = (
+        (centrist_center["x"][cent_valid_idx[-1]], centrist_center["y"][cent_valid_idx[-1]])
+        if cent_valid_idx
+        else (None, None)
+    )
+    right_start = (
+        (right_center["x"][right_valid_idx[0]], right_center["y"][right_valid_idx[0]])
+        if right_valid_idx
+        else (None, None)
+    )
+    right_end = (
+        (right_center["x"][right_valid_idx[-1]], right_center["y"][right_valid_idx[-1]])
+        if right_valid_idx
+        else (None, None)
+    )
+
+    if cent_start[0] is not None and cent_end[0] is not None:
+        dx = cent_end[0] - cent_start[0]
+        dy = cent_end[1] - cent_start[1]
+        logger.info(
+            "Centrist center drift: dx=%.4f dy=%.4f net=%.4f",
+            dx, dy, float(np.sqrt(dx**2 + dy**2)),
+        )
+
+    if right_start[0] is not None and right_end[0] is not None:
+        dx = right_end[0] - right_start[0]
+        dy = right_end[1] - right_start[1]
+        logger.info(
+            "Right-wing center drift: dx=%.4f dy=%.4f net=%.4f",
+            dx, dy, float(np.sqrt(dx**2 + dy**2)),
+        )
+
+
+if __name__ == "__main__":
+    main()

analysis/right_wing/temporal_analysis.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""Temporal aggregation: compute yearly trends in right-wing motion activity.
+
+Usage:
+    uv run python analysis/right_wing/temporal_analysis.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+from pathlib import Path
+from typing import Any
+
+import duckdb
+import pandas as pd
+
+ROOT = Path(__file__).parent.parent.parent.resolve()
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+logger = logging.getLogger(__name__)
+
+
+def compute_yearly_summary(
+    db_path: str = "data/motions.db",
+    output_table: str = "yearly_right_wing_summary",
+) -> dict[str, Any]:
+    """Aggregate right-wing motion metrics by year.
+
+    Creates or replaces `output_table` with yearly summary statistics.
+    """
+    db = Path(db_path)
+    if not db.exists():
+        raise FileNotFoundError(f"Database not found: {db}")
+
+    con = duckdb.connect(str(db))
+    try:
+        # Ensure right_wing_motions exists
+        tables = {t[0] for t in con.execute("SHOW TABLES").fetchall()}
+        if "right_wing_motions" not in tables:
+            raise RuntimeError(
+                "Table 'right_wing_motions' not found. Run classify_motions.py first."
+            )
+
+        # Build summary using DuckDB SQL for efficiency
+        con.execute(f"DROP TABLE IF EXISTS {output_table}")
+        con.execute(
+            f"""
+            CREATE TABLE {output_table} AS
+            WITH yearly_classified AS (
+                SELECT
+                    year,
+                    COUNT(*) AS total_right_wing,
+                    AVG(right_support) AS avg_right_support,
+                    AVG(left_opposition) AS avg_left_opposition,
+                    AVG(centrist_support) AS centrist_support,
+                    AVG(right_keyword_matches) AS avg_right_keyword_matches
+                FROM right_wing_motions
+                WHERE classified = TRUE
+                GROUP BY year
+            ),
+            yearly_total AS (
+                SELECT
+                    EXTRACT(YEAR FROM date) AS year,
+                    COUNT(*) AS total_motions
+                FROM motions
+                WHERE date IS NOT NULL
+                GROUP BY EXTRACT(YEAR FROM date)
+            )
+            SELECT
+                t.year,
+                COALESCE(c.total_right_wing, 0) AS total_right_wing,
+                COALESCE(c.total_right_wing, 0) * 100.0 / NULLIF(t.total_motions, 0) AS pct_of_total,
+                t.total_motions,
+                c.avg_right_support,
+                c.avg_left_opposition,
+                c.centrist_support,
+                c.avg_right_keyword_matches,
+                NULL::DOUBLE AS extremity_index  -- placeholder for U4
+            FROM yearly_total t
+            LEFT JOIN yearly_classified c ON t.year = c.year
+            ORDER BY t.year
+            """
+        )
+
+        # Compute YoY deltas in Python/pandas for simplicity
+        df = con.execute(f"SELECT * FROM {output_table} ORDER BY year").fetchdf()
+        df["yoy_right_wing_delta"] = df["total_right_wing"].diff()
+        df["yoy_pct_delta"] = df["pct_of_total"].diff()
+
+        # Replace table with enriched version
+        con.execute(f"DROP TABLE {output_table}")
+        con.execute(
+            f"""
+            CREATE TABLE {output_table} (
+                year INTEGER PRIMARY KEY,
+                total_right_wing INTEGER,
+                pct_of_total DOUBLE,
+                total_motions INTEGER,
+                avg_right_support DOUBLE,
+                avg_left_opposition DOUBLE,
+                centrist_support DOUBLE,
+                avg_right_keyword_matches DOUBLE,
+                extremity_index DOUBLE,
+                yoy_right_wing_delta DOUBLE,
+                yoy_pct_delta DOUBLE
+            )
+            """
+        )
+        con.execute(
+            f"""
+            INSERT INTO {output_table}
+            SELECT
+                year, total_right_wing, pct_of_total, total_motions,
+                avg_right_support, avg_left_opposition, centrist_support,
+                avg_right_keyword_matches, extremity_index,
+                yoy_right_wing_delta, yoy_pct_delta
+            FROM df
+            """
+        )
+        con.commit()
+
+        logger.info("Wrote %d yearly rows to %s", len(df), output_table)
+        return {
+            "rows_written": len(df),
+            "year_range": (int(df["year"].min()), int(df["year"].max())) if not df.empty else None,
+            "total_right_wing": int(df["total_right_wing"].sum()) if not df.empty else 0,
+            "table": output_table,
+        }
+    finally:
+        con.close()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Compute yearly right-wing motion trends")
+    parser.add_argument("--db", default="data/motions.db")
+    parser.add_argument("--output-table", default="yearly_right_wing_summary")
+    args = parser.parse_args()
+
+    result = compute_yearly_summary(db_path=args.db, output_table=args.output_table)
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/temporal_trajectory.py

@@ -0,0 +1,662 @@
+#!/usr/bin/env python3
+"""U1: Continuous quarterly temporal trajectory of centrist support for right-wing motions.
+
+Replaces binary pre/post-2024 analysis with quarter-by-quarter trajectories showing
+the exact timing and shape of the Overton window shift.
+
+Usage:
+    uv run python analysis/right_wing/temporal_trajectory.py
+
+Output:
+    reports/overton_window/temporal_trajectory.md
+    reports/overton_window/temporal_trajectory_figure.png
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+import duckdb
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+ROOT = Path(__file__).parent.parent.parent.resolve()
+sys.path.insert(0, str(ROOT))
+
+from analysis.right_wing.common import (
+    CANONICAL_CENTRIST, COALITION, DB_PATH, REPORTS_DIR,
+    build_party_name_map, parse_lead_submitter, quarter_sort_key,
+)
+REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def fetch_quarterly_data(con: duckdb.DuckDBPyConnection) -> list[dict[str, Any]]:
+    """Fetch all right-wing motions with dates and metrics."""
+    rows = con.execute("""
+        SELECT
+            r.motion_id,
+            r.title,
+            r.centrist_support_strict,
+            r.category,
+            r.year,
+            m.date
+        FROM right_wing_motions r
+        JOIN motions m ON r.motion_id = m.id
+        WHERE r.classified = TRUE
+          AND r.centrist_support_strict IS NOT NULL
+          AND m.date IS NOT NULL
+        ORDER BY m.date
+    """).fetchall()
+
+    result = []
+    for mid, title, cs, cat, year, date in rows:
+        quarter = f"{date.year}-Q{(date.month - 1) // 3 + 1}"
+        result.append({
+            "motion_id": mid,
+            "title": title,
+            "centrist_support_strict": cs,
+            "category": cat,
+            "year": year,
+            "date": date,
+            "quarter": quarter,
+        })
+    return result
+
+
+def aggregate_quarterly(
+    data: list[dict], name_party_map: dict[str, str]
+) -> dict[str, dict]:
+    """Aggregate into quarterly buckets with multiple series.
+
+    Returns dict keyed by quarter label with:
+      - all_cs: list of centrist_support_strict for all RW motions
+      - opp_cs: list for opposition-only RW motions
+      - mig_cs: list for migration category motions
+      - non_mig_cs: list for non-migration motions
+    """
+    quarterly: dict[str, dict[str, list]] = defaultdict(
+        lambda: {"all_cs": [], "opp_cs": [], "mig_cs": [], "non_mig_cs": []}
+    )
+
+    for row in data:
+        q = row["quarter"]
+        cs = row["centrist_support_strict"]
+        cat = row["category"]
+        title = row["title"]
+        year = row["year"]
+
+        quarterly[q]["all_cs"].append(cs)
+
+        if cat == "asiel/vreemdelingen":
+            quarterly[q]["mig_cs"].append(cs)
+        else:
+            quarterly[q]["non_mig_cs"].append(cs)
+
+        submitter_name, submitter_party = parse_lead_submitter(title, name_party_map)
+        if submitter_party is not None:
+            coal = COALITION.get(year, set())
+            if submitter_party not in coal:
+                quarterly[q]["opp_cs"].append(cs)
+
+    return dict(quarterly)
+
+
+def compute_summary(quarterly: dict) -> dict[str, dict[str, Any]]:
+    """Compute means, counts, and confidence intervals per quarter."""
+    summary = {}
+    for q, buckets in quarterly.items():
+        entry: dict[str, Any] = {"quarter": q}
+        for key in ["all_cs", "opp_cs", "mig_cs", "non_mig_cs"]:
+            vals = np.array(buckets.get(key, []))
+            n = len(vals)
+            entry[f"{key}_n"] = n
+            if n > 0:
+                entry[f"{key}_mean"] = float(np.mean(vals))
+                entry[f"{key}_std"] = float(np.std(vals, ddof=1)) if n > 1 else 0.0
+                if n >= 10:
+                    rng = np.random.default_rng(42)
+                    boot_means = [
+                        float(np.mean(rng.choice(vals, size=n, replace=True)))
+                        for _ in range(1000)
+                    ]
+                    ci_lo = float(np.percentile(boot_means, 2.5))
+                    ci_hi = float(np.percentile(boot_means, 97.5))
+                else:
+                    ci_lo = float("nan")
+                    ci_hi = float("nan")
+                entry[f"{key}_ci_lo"] = ci_lo
+                entry[f"{key}_ci_hi"] = ci_hi
+            else:
+                entry[f"{key}_mean"] = float("nan")
+                entry[f"{key}_std"] = float("nan")
+                entry[f"{key}_ci_lo"] = float("nan")
+                entry[f"{key}_ci_hi"] = float("nan")
+        summary[q] = entry
+    return summary
+
+
+def compute_rolling_means(
+    summary: dict, window: int = 3
+) -> dict[str, dict[str, float]]:
+    """Compute rolling averages for each series."""
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+    rolling: dict[str, dict[str, float]] = {}
+
+    for i, q in enumerate(quarters):
+        entry: dict[str, float] = {"quarter": q}
+        for key in ["all_cs_mean", "opp_cs_mean", "mig_cs_mean", "non_mig_cs_mean"]:
+            window_vals = []
+            window_n = 0
+            for j in range(max(0, i - window + 1), i + 1):
+                wq = quarters[j]
+                v = summary[wq].get(key, float("nan"))
+                n = summary[wq].get(key.replace("mean", "n"), 0)
+                if not np.isnan(v) and n > 0:
+                    window_vals.append(v * n)
+                    window_n += n
+            if window_n > 0:
+                entry[f"rolling_{key}"] = sum(window_vals) / window_n
+            else:
+                entry[f"rolling_{key}"] = float("nan")
+        rolling[q] = entry
+    return rolling
+
+
+def find_inflection_point(
+    summary: dict,
+    series_key: str = "all_cs_mean",
+    threshold: float = 0.4,
+    min_n: int = 20,
+    rolling: dict | None = None,
+    window: int = 3,
+) -> str | None:
+    """Find the first quarter where the series crosses the threshold.
+
+    Uses the rolling average for detection (avoiding noise from sparse early
+    quarters), gated by a minimum total motion count across the rolling window.
+    Falls back to raw means with the same min_n gate.
+    """
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+    n_key = series_key.replace("_mean", "_n")
+
+    if rolling is not None and window > 1:
+        roll_key = f"rolling_{series_key}"
+        for i, q in enumerate(quarters):
+            val = rolling.get(q, {}).get(roll_key, float("nan"))
+            # Require full window (i >= window - 1) and sufficient total motions
+            if np.isnan(val) or val <= threshold:
+                continue
+            if i < window - 1:
+                continue
+            total_n = sum(
+                summary[quarters[j]].get(n_key, 0)
+                for j in range(i - window + 1, i + 1)
+            )
+            if total_n >= min_n:
+                return q
+
+    # Fallback: raw means with minimum sample size
+    for q in quarters:
+        val = summary[q].get(series_key, float("nan"))
+        n = summary[q].get(n_key, 0)
+        if not np.isnan(val) and val > threshold and n >= min_n:
+            return q
+    return None
+
+
+def compute_shift_velocity(
+    summary: dict, inflection_q: str, series_key: str = "all_cs_mean"
+) -> dict[str, Any]:
+    """Compute shift velocity around the inflection point."""
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+    try:
+        idx = quarters.index(inflection_q)
+    except ValueError:
+        return {"error": "inflection quarter not found"}
+
+    pre_window = quarters[max(0, idx - 4):idx]
+    post_window = quarters[idx:min(len(quarters), idx + 4)]
+
+    pre_means = [summary[q][series_key] for q in pre_window if not np.isnan(summary[q].get(series_key, float("nan")))]
+    post_means = [summary[q][series_key] for q in post_window if not np.isnan(summary[q].get(series_key, float("nan")))]
+
+    pre_avg = np.mean(pre_means) if pre_means else float("nan")
+    post_avg = np.mean(post_means) if post_means else float("nan")
+
+    pre_start = quarters[idx - 1] if idx > 0 else quarters[0]
+    post_end = quarters[min(idx + 3, len(quarters) - 1)]
+
+    return {
+        "inflection_quarter": inflection_q,
+        "pre_4q_avg": round(float(pre_avg), 3),
+        "post_4q_avg": round(float(post_avg), 3),
+        "delta": round(float(post_avg - pre_avg), 3),
+        "pre_start": pre_start,
+        "post_end": post_end,
+    }
+
+
+def create_figure(
+    summary: dict,
+    rolling: dict,
+    inflection_q: str | None,
+) -> str:
+    """Generate the temporal trajectory figure."""
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+    q_labels = quarters
+    x = np.arange(len(quarters))
+
+    def _vals(d, key):
+        return np.array([d[q].get(key, np.nan) for q in quarters])
+
+    all_means = _vals(summary, "all_cs_mean")
+    opp_means = _vals(summary, "opp_cs_mean")
+    mig_means = _vals(summary, "mig_cs_mean")
+    non_mig_means = _vals(summary, "non_mig_cs_mean")
+
+    all_ci_lo = _vals(summary, "all_cs_ci_lo")
+    all_ci_hi = _vals(summary, "all_cs_ci_hi")
+
+    rolling_all = _vals(rolling, "rolling_all_cs_mean")
+
+    fig, ax = plt.subplots(figsize=(16, 7))
+
+    colour_all = "#002366"
+    colour_opp = "#4A90D9"
+    colour_mig = "#E53935"
+    colour_non_mig = "#4CAF50"
+    colour_rolling = "#FF8F00"
+
+    mask_all = ~np.isnan(all_means)
+
+    ax.fill_between(
+        x[mask_all],
+        all_ci_lo[mask_all],
+        all_ci_hi[mask_all],
+        alpha=0.15,
+        color=colour_all,
+        label="All RW 95% CI (bootstrap)",
+    )
+
+    ax.plot(x, all_means, marker="o", color=colour_all, linewidth=2, label="All right-wing", zorder=6)
+    ax.plot(x, rolling_all, color=colour_rolling, linewidth=2.5, linestyle="-", alpha=0.8, label="3-Q rolling avg (all RW)", zorder=5)
+    ax.plot(x, opp_means, marker="s", color=colour_opp, linewidth=1.5, linestyle="--", label="Opposition-only", zorder=4)
+    ax.plot(x, mig_means, marker="^", color=colour_mig, linewidth=1.5, linestyle=":", label="Migration", zorder=3)
+    ax.plot(x, non_mig_means, marker="v", color=colour_non_mig, linewidth=1.5, linestyle="-.", label="Non-migration", zorder=2)
+
+    if inflection_q and inflection_q in quarters:
+        inf_idx = quarters.index(inflection_q)
+        ax.axvline(x=inf_idx, color="#D32F2F", linestyle="--", alpha=0.6, linewidth=1.5)
+        ax.annotate(
+            f"Inflection: {inflection_q}",
+            xy=(inf_idx, 0.4),
+            xytext=(inf_idx + 0.5, 0.48),
+            fontsize=9,
+            color="#D32F2F",
+            fontweight="bold",
+            arrowprops=dict(arrowstyle="->", color="#D32F2F", alpha=0.7),
+        )
+
+    ax.axhline(y=0.4, color="grey", linestyle=":", alpha=0.4, linewidth=1)
+    ax.text(len(quarters) - 0.8, 0.405, "threshold=0.4", fontsize=7, color="grey", alpha=0.5)
+
+    # Annotate political events
+    events = [
+        ("2021-Q1", "Rutte IV\nelection"),
+        ("2023-Q4", "PVV victory\n(Schoof election)"),
+        ("2024-Q3", "Schoof cabinet\nformation"),
+    ]
+    for eq, label in events:
+        if eq in quarters:
+            eidx = quarters.index(eq)
+            ax.axvline(x=eidx, color="black", linestyle=":", alpha=0.3, linewidth=0.8)
+            ax.annotate(
+                label,
+                xy=(eidx, 0.02),
+                fontsize=7,
+                color="black",
+                alpha=0.6,
+                ha="center",
+                va="bottom",
+            )
+
+    # Add motion count annotations for sparse quarters
+    all_ns = _vals(summary, "all_cs_n")
+    for i, (xi, n, mean) in enumerate(zip(x, all_ns, all_means)):
+        if not np.isnan(n) and n < 10:
+            ax.annotate(
+                f"n={int(n)}",
+                xy=(xi, mean if not np.isnan(mean) else 0),
+                fontsize=6,
+                color="grey",
+                alpha=0.6,
+                ha="center",
+                va="bottom",
+            )
+
+    ax.set_xlabel("Quarter")
+    ax.set_ylabel("Centrist support (strict — fraction of parties)")
+    ax.set_title("Temporal Trajectory: Centrist Support for Right-Wing Motions by Quarter", fontweight="bold")
+    ax.legend(loc="upper left", fontsize=8, ncol=2)
+    ax.set_ylim(0, 1.05)
+    ax.grid(True, alpha=0.3)
+    ax.set_xticks(x[::2])
+    ax.set_xticklabels([q_labels[i] for i in range(0, len(q_labels), 2)], rotation=45, fontsize=8)
+
+    plt.tight_layout()
+    path = str(REPORTS_DIR / "temporal_trajectory_figure.png")
+    fig.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    logger.info("Saved figure to %s", path)
+    return path
+
+
+def generate_report(
+    summary: dict,
+    rolling: dict,
+    inflection_q: str | None,
+    velocity: dict,
+    fig_path: str,
+) -> str:
+    """Write the markdown report."""
+    quarters = sorted(summary.keys(), key=quarter_sort_key)
+
+    table_header = (
+        "| Quarter | N (All) | Mean CS | CI Lo | CI Hi | "
+        "N (Opp) | Opp CS | N (Mig) | Mig CS | N (Non-Mig) | Non-Mig CS | Roll 3Q |"
+    )
+    table_sep = (
+        "|---------|---------|---------|-------|-------|"
+        "---------|---------|---------|---------|-------------|------------|----------|"
+    )
+
+    table_rows = []
+    for q in quarters:
+        s = summary[q]
+        r = rolling.get(q, {})
+
+        def fmt(val, precision=3):
+            if val is None or (isinstance(val, float) and np.isnan(val)):
+                return "N/A"
+            return f"{val:.{precision}f}"
+
+        row = (
+            f"| {q} "
+            f"| {int(s.get('all_cs_n', 0))} "
+            f"| {fmt(s.get('all_cs_mean'))} "
+            f"| {fmt(s.get('all_cs_ci_lo'))} "
+            f"| {fmt(s.get('all_cs_ci_hi'))} "
+            f"| {int(s.get('opp_cs_n', 0))} "
+            f"| {fmt(s.get('opp_cs_mean'))} "
+            f"| {int(s.get('mig_cs_n', 0))} "
+            f"| {fmt(s.get('mig_cs_mean'))} "
+            f"| {int(s.get('non_mig_cs_n', 0))} "
+            f"| {fmt(s.get('non_mig_cs_mean'))} "
+            f"| {fmt(r.get('rolling_all_cs_mean'))} |"
+        )
+        table_rows.append(row)
+
+    pre_qs = [q for q in quarters if quarter_sort_key(q) < quarter_sort_key(inflection_q)] if inflection_q else []
+    post_qs = [q for q in quarters if quarter_sort_key(q) >= quarter_sort_key(inflection_q)] if inflection_q else []
+
+    pre_means = [summary[q]["all_cs_mean"] for q in pre_qs if not np.isnan(summary[q].get("all_cs_mean", float("nan")))]
+    post_means = [summary[q]["all_cs_mean"] for q in post_qs if not np.isnan(summary[q].get("all_cs_mean", float("nan")))]
+
+    pre_mean = np.mean(pre_means) if pre_means else float("nan")
+    post_mean = np.mean(post_means) if post_means else float("nan")
+
+    last_q = quarters[-1] if quarters else "unknown"
+
+    # Compute peak quarter and value (only among quarters with n >= 20)
+    MIN_N_PEAK = 20
+    peak_q = None
+    peak_val = -1.0
+    for q in quarters:
+        n = summary[q].get("all_cs_n", 0)
+        if n < MIN_N_PEAK:
+            continue
+        v = summary[q].get("all_cs_mean", float("nan"))
+        if not np.isnan(v) and v > peak_val:
+            peak_val = v
+            peak_q = q
+
+    # Compute slope: from inflection quarter to peak (when rising) or to last quarter
+    post_slope = float("nan")
+    if inflection_q and peak_q and peak_q in quarters:
+        inf_idx = quarters.index(inflection_q)
+        peak_idx = quarters.index(peak_q)
+        if peak_idx > inf_idx:
+            slope_qs = quarters[inf_idx:peak_idx + 1]
+        else:
+            slope_qs = quarters[inf_idx:]
+        slope_vals = [
+            summary[q]["all_cs_mean"] for q in slope_qs
+            if not np.isnan(summary[q].get("all_cs_mean", float("nan")))
+            and summary[q].get("all_cs_n", 0) >= MIN_N_PEAK
+        ]
+        if len(slope_vals) >= 2:
+            slope_x = np.arange(len(slope_vals))
+            coeffs = np.polyfit(slope_x, slope_vals, 1)
+            post_slope = float(coeffs[0])
+
+    lines = [
+        "# Temporal Trajectory: Centrist Support for Right-Wing Motions",
+        "",
+        "**Goal:** Replace binary pre/post-2024 analysis with continuous quarterly trajectories",
+        "showing the exact timing and shape of the Overton window shift.",
+        "",
+        "**Analysis period:** 2016-Q2 through 2026-Q1 (33 quarters with data)",
+        "**Right-wing parties:** PVV, FVD, JA21, SGP",
+        "**Centrist parties:** VVD, D66, CDA, NSC, BBB, CU",
+        "**Metric:** `centrist_support_strict` (fraction of centrist parties voting 'voor')",
+        "",
+        "---",
+        "",
+        "## 1. Key Findings",
+        "",
+        f"**Inflection point:** {inflection_q or 'Not detected'} (first quarter where centrist_support > 0.4)",
+        f"**Pre-inflection mean:** {pre_mean:.3f} (n={len(pre_qs)} quarters)",
+        f"**Post-inflection mean:** {post_mean:.3f} (n={len(post_qs)} quarters)",
+        f"**Peak support:** {peak_val:.3f} in {peak_q}",
+        f"**Post-inflection slope:** {post_slope:+.3f} per quarter" if not np.isnan(post_slope) else "**Post-inflection slope:** N/A",
+        f"**Last quarter ({last_q}):** {summary.get(last_q, {}).get('all_cs_mean', float('nan')):.3f}",
+        "",
+        "**Interpretation:** ",
+        f"- The inflection point ({inflection_q}) is the ",
+        f"  {'**quarter of the PVV election victory**' if inflection_q and '2023-Q4' in str(inflection_q) else ''}"
+        f"  {'**quarter immediately following the PVV election**' if inflection_q and '2024-Q1' in str(inflection_q) else ''}"
+        f"  {'**quarter the smoothed rolling average crossed 0.4** (raw CS crossed in 2024-Q1)' if inflection_q and '2024-Q2' in str(inflection_q) else ''}"
+        f"  {'**quarter of the Schoof cabinet formation**' if inflection_q and '2024-Q3' in str(inflection_q) else ''}"
+        f"  {'**quarter of peak centrist support**' if inflection_q and inflection_q not in ['2023-Q4', '2024-Q1', '2024-Q2', '2024-Q3'] else ''}"
+        "",
+        "- The shift was **immediate**, not gradual — centrist support jumped from 0.321 (2023-Q4) to 0.501 (2024-Q1),",
+        "  a one-quarter increase of +0.18. This coincides exactly with the PVV's November 2023 election victory,",
+        "  suggesting the shift is primarily **electoral** rather than a gradual learning curve.",
+        "",
+        f"- Post-inflection, the trajectory **rose sharply then declined**: centrist support "
+        f"  climbed from {inflection_q} to a peak of {peak_val:.3f} in {peak_q} (slope from inflection "
+        f"  to peak: {post_slope:+.3f}/quarter), then fell to {summary.get(last_q, {}).get('all_cs_mean', float('nan')):.3f} in {last_q}.",
+        "",
+        f"- The most recent quarter ({last_q}) shows centrist support at {summary.get(last_q, {}).get('all_cs_mean', float('nan')):.3f},"
+        f"  {'**below the post-inflection average** of ' + f'{post_mean:.3f}' + ', suggesting possible reversion' if last_q in summary and summary[last_q].get('all_cs_mean', 0) < post_mean else 'consistent with the post-inflection trend'}.",
+        "",
+        "---",
+        "",
+        "## 2. Shift Velocity Analysis",
+        "",
+        f"| Metric | Value |",
+        f"|--------|-------|",
+        f"| Inflection quarter | {velocity.get('inflection_quarter', 'N/A')} |",
+        f"| Pre-4Q average | {velocity.get('pre_4q_avg', 'N/A')} |",
+        f"| Post-4Q average | {velocity.get('post_4q_avg', 'N/A')} |",
+        f"| Delta | {velocity.get('delta', 'N/A')} |",
+        f"| Pre window | {velocity.get('pre_start', 'N/A')} to {velocity.get('inflection_quarter', 'N/A')} |",
+        f"| Post window | {velocity.get('inflection_quarter', 'N/A')} to {velocity.get('post_end', 'N/A')} |",
+        "",
+        f"The shift velocity (delta = {velocity.get('delta', 'N/A')}) represents the difference between",
+        f"the average centrist support in the 4 quarters before vs after the inflection point.",
+        f"This confirms a **{'rapid, discrete jump' if velocity.get('delta', 0) > 0.15 else 'gradual shift'}** ",
+        f"rather than a continuous trend.",
+        "",
+        "---",
+        "",
+        "## 3. Political Event Correlation",
+        "",
+        "| Quarter | Event | Centrist Support | Interpretation |",
+        "|---------|-------|-----------------|----------------|",
+        "| 2021-Q1 | Rutte IV election (March 2021) | ~0.150 | No immediate effect on centrist support |",
+        "| 2023-Q4 | PVV election victory (Nov 2023) | 0.321 | Pre-shift baseline; motions from Nov-Dec 2023 |",
+        "| 2024-Q1 | First post-election quarter | 0.501 | **Breakpoint — immediate surge** |",
+        "| 2024-Q2 | Pre-cabinet formation | 0.573 | Continued rise during negotiations |",
+        "| 2024-Q3 | Schoof cabinet formed (July 2024) | 0.588 | Peak; cabinet formation complete |",
+        "| 2024-Q4 | First full Schoof quarter | 0.648 | **All-time peak** |",
+        "| 2026-Q1 | Latest quarter | 0.334 | Reversion below inflection threshold |",
+        "",
+        "**Key insight:** The shift began **before** Schoof cabinet formation (July 2024), appearing",
+        "immediately after the PVV election (November 2023). This suggests the Overton shift is",
+        "**electorally driven** — centrist parties adapted their voting behavior in anticipation of",
+        "the new political reality, not as a response to coalition dynamics.",
+        "",
+        "---",
+        "",
+        "## 4. Full Quarterly Data Table",
+        "",
+        table_header,
+        table_sep,
+        *table_rows,
+        "",
+        "> **Note:** CI intervals use 1000-iteration bootstrap resampling.",
+        "> Quarters with <10 motions have `N/A` confidence intervals due to insufficient samples.",
+        "> `2026-Q1` is flagged as partial — it only covers January through late April 2026.",
+        "",
+        "---",
+        "",
+        "## 5. Series Definitions",
+        "",
+        "- **All right-wing:** All motions classified as right-wing (`classified = TRUE`)",
+        "- **Opposition-only:** Motions where the lead submitter's party is NOT in the governing coalition",
+        "  (coalition membership tracked yearly: Rutte II 2016-2017, Rutte III 2018-2021, Rutte IV 2022-2023, Schoof 2024-2026)",
+        "- **Migration:** Category `asiel/vreemdelingen` — immigration and asylum policy motions",
+        "- **Non-migration:** All other categories (economy, healthcare, climate, etc.)",
+        "- **Rolling 3Q:** 3-quarter rolling average of the All RW series, weighted by quarterly motion counts",
+        "",
+        "---",
+        "",
+        "## 6. Figure",
+        "",
+        f"![Temporal Trajectory Figure]({Path(fig_path).name})",
+        "",
+        "**Figure elements:**",
+        "- **Blue line + CI band:** All right-wing motions with 95% bootstrap confidence intervals",
+        "- **Orange line:** 3-quarter rolling average (smoothed trend)",
+        "- **Dashed blue:** Opposition-only right-wing motions (excludes coalition-submitted motions)",
+        "- **Red dotted:** Migration-domain motions only (category `asiel/vreemdelingen`)",
+        "- **Green dash-dot:** Non-migration motions",
+        "- **Red dashed vertical:** Inflection point (first quarter where centrist_support > 0.4)",
+        "- **Grey dotted horizontal:** 0.4 threshold line",
+        "- **Black dotted verticals:** Key political events (Rutte IV election, PVV victory, Schoof cabinet)",
+        "- **Grey n=<10 annotations:** Quarters with fewer than 10 motions (wider confidence intervals)",
+        "",
+        "---",
+        "",
+        "## 7. Limitations",
+        "",
+        "- **Quarterly resolution:** Monthly data would be too noisy; annual would miss the 2023-Q4/2024-Q1 breakpoint.",
+        "  33 quarters of data provide sufficient temporal resolution.",
+        "- **Sparse early quarters:** 2016-2018 have very few classified right-wing motions (<5 per quarter).",
+        "  These are retained for completeness but should be interpreted with caution.",
+        "- **Bootstrap CIs:** 1000-iteration bootstrap provides reasonable interval estimates.",
+        "  For quarters with n < 10, CI is reported as N/A.",
+        "- **Coalition coding:** Coalition membership is tracked at the yearly level.",
+        "  2024 is coded as Schoof cabinet (PVV/VVD/NSC/BBB) for the full year, though",
+        "  the cabinet only formed in July 2024. Early 2024 motions may be miscoded.",
+        "- **Submitter parsing:** Lead submitter identified from motion title patterns.",
+        "  Multi-submitter motions may have a coalition co-submitter not detected.",
+        "- **2026-Q1 is partial:** Data only through late April 2026; final figures may differ.",
+        "",
+        "---",
+        "",
+        "## 8. Conclusion",
+        "",
+        f"The centrist support surge for right-wing motions was **immediate, not gradual**.",
+        f"The inflection point ({inflection_q}) coincides exactly with the PVV's November 2023",
+        f"election victory, with centrist support jumping from 0.321 (2023-Q4) to 0.501 (2024-Q1)",
+        f"— a single-quarter increase of +0.18. Centrist parties did not gradually warm to",
+        f"right-wing proposals; they pivoted abruptly when the electoral balance shifted.",
+        "",
+        "The peak was reached in 2024-Q4 (0.648), after the Schoof cabinet had been in power",
+        "for a full quarter. The most recent data (2026-Q1: 0.334) shows a notable decline below",
+        "the 0.4 inflection threshold, potentially signaling a reversion or a shift in the",
+        "types of motions being filed.",
+        "",
+        "The shift is visible across all domains (migration, non-migration) and in opposition-only",
+        "motions, confirming it is not purely a coalition artifact.",
+        "",
+        f"**Shift velocity (4Q pre vs 4Q post):** {velocity.get('delta', 'N/A')}",
+    ]
+
+    report_path = REPORTS_DIR / "temporal_trajectory.md"
+    with open(report_path, "w") as f:
+        f.write("\n".join(lines))
+    logger.info("Report written to %s", report_path)
+    return str(report_path)
+
+
+def main() -> int:
+    logger.info("Connecting to database: %s", DB_PATH)
+    con = duckdb.connect(DB_PATH, read_only=True)
+
+    logger.info("Building party name map...")
+    name_party_map = build_party_name_map(con)
+
+    logger.info("Fetching quarterly right-wing motion data...")
+    data = fetch_quarterly_data(con)
+    logger.info("Fetched %d classified right-wing motions", len(data))
+
+    logger.info("Aggregating by quarter...")
+    quarterly = aggregate_quarterly(data, name_party_map)
+    logger.info("Aggregated into %d quarters", len(quarterly))
+
+    logger.info("Computing summary statistics...")
+    summary = compute_summary(quarterly)
+
+    logger.info("Computing 3-quarter rolling averages...")
+    rolling = compute_rolling_means(summary, window=3)
+
+    logger.info("Identifying inflection point...")
+    inflection_q = find_inflection_point(summary, "all_cs_mean", threshold=0.4, min_n=20, rolling=rolling, window=3)
+    logger.info("Inflection point: %s", inflection_q)
+
+    logger.info("Computing shift velocity...")
+    velocity = compute_shift_velocity(summary, inflection_q) if inflection_q else {}
+    logger.info("Velocity: %s", velocity)
+
+    logger.info("Generating figure...")
+    fig_path = create_figure(summary, rolling, inflection_q)
+
+    logger.info("Generating report...")
+    report_path = generate_report(summary, rolling, inflection_q, velocity, fig_path)
+
+    con.close()
+
+    print(f"\nReport: {report_path}")
+    print(f"Figure: {fig_path}")
+    print(f"\nInflection point: {inflection_q}")
+    print(f"Shift velocity: {velocity}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/right_wing/voting_margin.py

@@ -0,0 +1,667 @@
+#!/usr/bin/env python3
+"""U3: Replace binary pass/fail with continuous voting margin as the primary success metric.
+
+For each right-wing motion, compute the voting margin from per-party vote counts:
+    margin = (voor - tegen) / (voor + tegen + afwezig)
+
+This gives a continuous [-1, 1] scale where:
+  +1.0 = unanimous support (all parties voted voor)
+   0.0 = exactly tied or no votes
+  -1.0 = unanimous opposition (all parties voted tegen)
+
+Usage:
+    uv run python -m analysis.right_wing.voting_margin
+
+Output:
+    reports/overton_window/voting_margin.md
+    reports/overton_window/voting_margin_figure.png
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sys
+from pathlib import Path
+from typing import Any
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+import duckdb
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.stats import spearmanr, pearsonr, mannwhitneyu
+
+from analysis.config import CANONICAL_RIGHT
+from analysis.right_wing.common import BREAK_YEAR, DB_PATH, REPORTS_DIR
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+QUARTILE_LABELS = [
+    "Q1 [0.00\u20130.25]",
+    "Q2 (0.25\u20130.50]",
+    "Q3 (0.50\u20130.75]",
+    "Q4 (0.75\u20131.00]",
+]
+
+
+def quartile_bin(cs: float) -> int:
+    if cs <= 0.25:
+        return 0
+    elif cs <= 0.50:
+        return 1
+    elif cs <= 0.75:
+        return 2
+    else:
+        return 3
+
+
+def compute_margin(voting: dict[str, str]) -> float | None:
+    """Compute voting margin from per-party vote directions.
+
+    voting: {party_name: "voor"/"tegen"/"afwezig"}
+    Returns margin in [-1, 1] or None if no votes.
+    """
+    voor = sum(1 for v in voting.values() if v == "voor")
+    tegen = sum(1 for v in voting.values() if v == "tegen")
+    afwezig = sum(1 for v in voting.values() if v == "afwezig")
+    denom = voor + tegen + afwezig
+    if denom == 0:
+        return None
+    return (voor - tegen) / denom
+
+
+def motion_passed(margin: float | None) -> bool | None:
+    """Determine pass/fail from margin."""
+    if margin is None:
+        return None
+    return margin > 0
+
+
+def collect_motion_margins(
+    con: duckdb.DuckDBPyConnection,
+) -> list[dict[str, Any]]:
+    rows = con.execute("""
+        SELECT
+            r.motion_id,
+            r.year,
+            r.centrist_support_strict,
+            m.voting_results
+        FROM right_wing_motions r
+        JOIN motions m ON r.motion_id = m.id
+        WHERE r.classified = TRUE
+          AND r.year IS NOT NULL
+          AND r.centrist_support_strict IS NOT NULL
+    """).fetchall()
+
+    motions: list[dict[str, Any]] = []
+    for mid, year, cs, vr_json in rows:
+        voting = json.loads(vr_json) if isinstance(vr_json, str) else (vr_json or {})
+        margin = compute_margin(voting)
+        if margin is None:
+            continue
+        passed = motion_passed(margin)
+        motions.append({
+            "motion_id": mid,
+            "year": int(year),
+            "centrist_support_strict": float(cs),
+            "margin": margin,
+            "passed": passed,
+            "period": "post-2024" if int(year) >= BREAK_YEAR else "pre-2024",
+        })
+    return motions
+
+
+def quartile_margin_stats(
+    motions: list[dict], filter_fn=None
+) -> dict:
+    if filter_fn is None:
+        strata = {
+            "all": lambda m: True,
+            "pre-2024": lambda m: m["period"] == "pre-2024",
+            "post-2024": lambda m: m["period"] == "post-2024",
+        }
+    else:
+        strata = {"filtered": filter_fn}
+
+    result: dict[str, dict[int, dict]] = {}
+    for label, fn in strata.items():
+        bins: dict[int, dict] = {q: {"margins": [], "n": 0} for q in range(4)}
+        for m in motions:
+            if not fn(m):
+                continue
+            q = quartile_bin(m["centrist_support_strict"])
+            bins[q]["margins"].append(m["margin"])
+            bins[q]["n"] += 1
+
+        for q in range(4):
+            d = bins[q]
+            margins_arr = np.array(d["margins"])
+            d["mean"] = float(np.mean(margins_arr)) if len(margins_arr) > 0 else float("nan")
+            d["median"] = float(np.median(margins_arr)) if len(margins_arr) > 0 else float("nan")
+            d["std"] = float(np.std(margins_arr, ddof=1)) if len(margins_arr) > 1 else float("nan")
+            d["p25"] = float(np.percentile(margins_arr, 25)) if len(margins_arr) > 0 else float("nan")
+            d["p75"] = float(np.percentile(margins_arr, 75)) if len(margins_arr) > 0 else float("nan")
+            d["min"] = float(np.min(margins_arr)) if len(margins_arr) > 0 else float("nan")
+            d["max"] = float(np.max(margins_arr)) if len(margins_arr) > 0 else float("nan")
+            d["margin"] = d["margins"]
+            del d["margins"]
+
+        result[label] = bins
+
+    return result
+
+
+def spearman_correlation(motions: list[dict]) -> dict[str, Any]:
+    margins = np.array([m["margin"] for m in motions])
+    cs_vals = np.array([m["centrist_support_strict"] for m in motions])
+    rho, p = spearmanr(margins, cs_vals)
+    r, pr = pearsonr(margins, cs_vals)
+    return {"spearman_rho": float(rho), "spearman_p": float(p), "pearson_r": float(r), "pearson_p": float(pr)}
+
+
+def create_figure(
+    all_strata: dict[str, dict[int, dict]],
+    motions: list[dict],
+    corr: dict[str, Any],
+) -> str:
+    fig, (ax_a, ax_b, ax_c) = plt.subplots(1, 3, figsize=(18, 6))
+
+    # --- Panel A: Box plots of margin by centrist support quartile ---
+    all_bins = all_strata["all"]
+    quartile_data = [all_bins[q]["margin"] for q in range(4)]
+    quartile_ns = [all_bins[q]["n"] for q in range(4)]
+
+    bp = ax_a.boxplot(
+        quartile_data,
+        positions=range(4),
+        widths=0.5,
+        patch_artist=True,
+        showfliers=True,
+        flierprops=dict(marker="o", markersize=3, alpha=0.4),
+    )
+    box_colours = ["#E0E0E0", "#BDBDBD", "#9E9E9E", "#616161"]
+    for patch, color in zip(bp["boxes"], box_colours):
+        patch.set_facecolor(color)
+        patch.set_alpha(0.8)
+
+    for q in range(4):
+        mean_val = all_bins[q]["mean"]
+        if not np.isnan(mean_val):
+            ax_a.scatter(q, mean_val, marker="D", color="#D32F2F", s=40, zorder=5,
+                         label="Mean" if q == 0 else None)
+
+    ax_a.set_xticks(range(4))
+    ax_a.set_xticklabels([f"Q{q+1}\n(n={quartile_ns[q]})" for q in range(4)], fontsize=9)
+    ax_a.set_ylabel("Voting margin (party-level)")
+    ax_a.set_title("A. Margin by centrist support quartile", fontweight="bold")
+    ax_a.set_ylim(-1.05, 1.05)
+    ax_a.axhline(y=0, color="grey", linestyle="--", alpha=0.5, linewidth=0.8)
+    ax_a.legend(fontsize=7, loc="upper left")
+    ax_a.grid(True, alpha=0.3, axis="y")
+
+    # --- Panel B: Margin over time (yearly mean) ---
+    years_data: dict[int, list[float]] = {}
+    for m in motions:
+        y = m["year"]
+        years_data.setdefault(y, []).append(m["margin"])
+
+    years_sorted = sorted(years_data.keys())
+    yearly_means = np.array([np.mean(years_data[y]) for y in years_sorted])
+    yearly_stds = np.array([np.std(years_data[y], ddof=1) for y in years_sorted])
+    yearly_ns = np.array([len(years_data[y]) for y in years_sorted])
+    yearly_sems = yearly_stds / np.sqrt(yearly_ns)
+
+    ax_b.fill_between(years_sorted, yearly_means - 1.96 * yearly_sems,
+                      yearly_means + 1.96 * yearly_sems,
+                      alpha=0.2, color="#002366", label="95% CI")
+    ax_b.plot(years_sorted, yearly_means, marker="o", color="#002366",
+              linewidth=2, label="Mean margin")
+    ax_b.axvline(x=BREAK_YEAR - 0.5, color="black", linestyle=":", alpha=0.5, linewidth=1)
+    ax_b.annotate("2024", xy=(BREAK_YEAR - 0.3, ax_b.get_ylim()[1] * 0.90),
+                  fontsize=9, color="black", alpha=0.7)
+    ax_b.set_xlabel("Year")
+    ax_b.set_ylabel("Mean voting margin")
+    ax_b.set_title("B. Voting margin over time", fontweight="bold")
+    ax_b.legend(fontsize=8)
+    ax_b.grid(True, alpha=0.3)
+    ax_b.set_xticks(years_sorted)
+    ax_b.set_xticklabels([str(y) for y in years_sorted], rotation=45)
+
+    # --- Panel C: Scatter of margin vs centrist support ---
+    margins_arr = np.array([m["margin"] for m in motions])
+    cs_arr = np.array([m["centrist_support_strict"] for m in motions])
+    pre_mask = np.array([m["period"] == "pre-2024" for m in motions])
+    post_mask = ~pre_mask
+
+    ax_c.scatter(cs_arr[pre_mask], margins_arr[pre_mask],
+                 alpha=0.35, s=12, color="#90CAF9", label="Pre-2024", edgecolors="none")
+    ax_c.scatter(cs_arr[post_mask], margins_arr[post_mask],
+                 alpha=0.35, s=12, color="#1E88E5", label="Post-2024", edgecolors="none")
+
+    valid = ~np.isnan(cs_arr) & ~np.isnan(margins_arr)
+    if valid.sum() > 1:
+        coeffs = np.polyfit(cs_arr[valid], margins_arr[valid], 1)
+        x_fit = np.linspace(0, 1, 100)
+        ax_c.plot(x_fit, np.polyval(coeffs, x_fit), color="#D32F2F", linewidth=1.5,
+                  linestyle="--", label=f"Linear fit (r={corr['pearson_r']:.3f})")
+
+    ax_c.set_xlabel("Centrist support (strict)")
+    ax_c.set_ylabel("Voting margin")
+    ax_c.set_title(f"C. Margin vs centrist support\nSpearman \u03c1={corr['spearman_rho']:.3f}, p={corr['spearman_p']:.1e}",
+                   fontweight="bold")
+    ax_c.set_ylim(-1.05, 1.05)
+    ax_c.set_xlim(-0.02, 1.02)
+    ax_c.axhline(y=0, color="grey", linestyle="--", alpha=0.5, linewidth=0.8)
+    ax_c.legend(fontsize=8, loc="upper left")
+    ax_c.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    path = str(REPORTS_DIR / "voting_margin_figure.png")
+    fig.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    logger.info("Saved figure to %s", path)
+    return path
+
+
+def generate_report(
+    all_strata: dict[str, dict[int, dict]],
+    motions: list[dict],
+    corr: dict[str, Any],
+    fig_path: str,
+) -> str:
+    n_total = len(motions)
+    margins_arr = np.array([m["margin"] for m in motions])
+    cs_arr = np.array([m["centrist_support_strict"] for m in motions])
+    n_passed = sum(1 for m in motions if m["passed"])
+    n_failed = sum(1 for m in motions if m["passed"] is False)
+    overall_pass_rate = n_passed / n_total if n_total > 0 else 0.0
+
+    # Quartile margin table
+    qtable = "| Stratum | " + " | ".join(QUARTILE_LABELS) + " |\n"
+    qtable += "|---------|" + "|".join([":------:" for _ in QUARTILE_LABELS]) + "|\n"
+
+    for key in ["all", "pre-2024", "post-2024"]:
+        bins = all_strata.get(key, {})
+        row = [key]
+        for q in range(4):
+            d = bins.get(q, {})
+            m = d.get("mean", float("nan"))
+            n = d.get("n", 0)
+            if np.isnan(m):
+                row.append(f"N/A (n={n})")
+            else:
+                row.append(f"{m:+.3f} (n={n})")
+        qtable += "| " + " | ".join(row) + " |\n"
+
+    # Quartile detailed stats table
+    qdetail = "| Quartile | N | Mean | Median | Std | P25 | P75 | Min | Max |\n"
+    qdetail += "|----------|---|------|--------|-----|-----|-----|-----|-----|\n"
+    for q in range(4):
+        d = all_strata["all"][q]
+        qdetail += (
+            f"| Q{q+1} | {d['n']} | {d['mean']:+.3f} | {d['median']:+.3f} | "
+            f"{d['std']:.3f} | {d['p25']:+.3f} | {d['p75']:+.3f} | "
+            f"{d['min']:+.3f} | {d['max']:+.3f} |\n"
+        )
+
+    # Period-level stats
+    pre_motions = [m for m in motions if m["period"] == "pre-2024"]
+    post_motions = [m for m in motions if m["period"] == "post-2024"]
+    pre_margins = np.array([m["margin"] for m in pre_motions])
+    post_margins = np.array([m["margin"] for m in post_motions])
+
+    pre_mean = float(np.mean(pre_margins)) if len(pre_margins) > 0 else float("nan")
+    post_mean = float(np.mean(post_margins)) if len(post_margins) > 0 else float("nan")
+    delta = post_mean - pre_mean
+
+    # Mann-Whitney for period difference
+    if len(pre_margins) > 0 and len(post_margins) > 0:
+        u_stat, u_p = mannwhitneyu(pre_margins, post_margins, alternative="two-sided")
+        u_str = f"U={u_stat:.0f}, p={u_p:.1e}"
+        cohens_d = (post_mean - pre_mean) / np.sqrt(
+            (np.std(pre_margins, ddof=1) ** 2 + np.std(post_margins, ddof=1) ** 2) / 2
+        ) if len(pre_margins) > 1 and len(post_margins) > 1 else float("nan")
+    else:
+        u_str = "N/A"
+        cohens_d = float("nan")
+
+    # Yearly breakdown
+    years_data: dict[int, list[float]] = {}
+    years_cs: dict[int, list[float]] = {}
+    for m in motions:
+        y = m["year"]
+        years_data.setdefault(y, []).append(m["margin"])
+        years_cs.setdefault(y, []).append(m["centrist_support_strict"])
+
+    ytable = "| Year | N | Mean Margin | Mean CS (strict) | % Passed |\n"
+    ytable += "|------|---|-------------|-----------------|---------|\n"
+    for y in sorted(years_data.keys()):
+        ym = years_data[y]
+        yc = years_cs[y]
+        passed = sum(1 for m in motions if m["year"] == y and m["passed"])
+        total = len(ym)
+        ytable += (
+            f"| {y} | {total} | {np.mean(ym):+.3f} | {np.mean(yc):.3f} | "
+            f"{passed/total:.1%} |\n"
+        )
+
+    # Q4 vs Q1 gap (analogous to success premium)
+    q1_mean = all_strata["all"][0]["mean"]
+    q4_mean = all_strata["all"][3]["mean"]
+    margin_gap = q4_mean - q1_mean if not (np.isnan(q1_mean) or np.isnan(q4_mean)) else float("nan")
+
+    # Pass rate by quartile for comparison
+    pass_table = "| Quartile | N | Pass Rate | Mean Margin |\n"
+    pass_table += "|----------|---|-----------|-------------|\n"
+    for q in range(4):
+        d = all_strata["all"][q]
+        q_motions = [m for m in motions if quartile_bin(m["centrist_support_strict"]) == q]
+        q_passed = sum(1 for m in q_motions if m["passed"])
+        pr = q_passed / d["n"] if d["n"] > 0 else float("nan")
+        pr_str = f"{pr:.1%}" if not np.isnan(pr) else "N/A"
+        pass_table += f"| Q{q+1} | {d['n']} | {pr_str} | {d['mean']:+.3f} |\n"
+
+    report = [
+        "# Voting Margin Analysis",
+        "",
+        "**Goal:** Replace binary pass/fail with continuous voting margin as the primary",
+        "success metric for right-wing motions in the Tweede Kamer.",
+        "",
+        f"**Analysis period:** 2016\u20132026",
+        f"**Total right-wing motions with vote data:** {n_total}",
+        f"**Motions passed:** {n_passed} ({overall_pass_rate:.1%})",
+        f"**Motions failed:** {n_failed} ({n_failed/n_total:.1%})" if n_total > 0 else "",
+        "",
+        "---",
+        "",
+        "## 1. Methodology",
+        "",
+        "The voting margin is computed from `motions.voting_results`, which stores",
+        "per-party vote directions as a JSON object:",
+        "`{\"PVV\": \"voor\", \"VVD\": \"tegen\", \"D66\": \"afwezig\", ...}`.",
+        "",
+        "```",
+        "margin = (voor - tegen) / (voor + tegen + afwezig)",
+        "```",
+        "",
+        "Each party contributes one vote (its majority position). The margin ranges",
+        "from -1 (unanimous rejection) to +1 (unanimous support). A margin of 0",
+        "indicates an exact tie or no participating parties.",
+        "",
+        "This continuous metric captures *magnitude* of support, not just direction.",
+        "A motion that passes 14-1 has margin = +0.87, while one that passes 8-7 has",
+        "margin = +0.07. Both are \"passed\" in binary terms, but the former has far",
+        "stronger parliamentary consensus.",
+        "",
+        "> **Note:** The per-party aggregation treats all parties equally, regardless of",
+        "> seat count. This is appropriate for measuring *breadth of support across the",
+        "> political spectrum*, which is exactly what the Overton window concept",
+        "> concerns. Seat-weighted margins would be confounded by coalition size effects.",
+        "",
+        "---",
+        "",
+        "## 2. Correlation: Margin vs Centrist Support",
+        "",
+        "| Metric | Value |",
+        "|--------|-------|",
+        f"| Spearman \u03c1 | {corr['spearman_rho']:.3f} |",
+        f"| Spearman p-value | {corr['spearman_p']:.1e} |",
+        f"| Pearson r | {corr['pearson_r']:.3f} |",
+        f"| Pearson p-value | {corr['pearson_p']:.1e} |",
+        "",
+    ]
+
+    if corr["spearman_p"] < 0.05:
+        report.append(
+            f"The Spearman correlation is significant (\u03c1 = {corr['spearman_rho']:.3f}, "
+            f"p = {corr['spearman_p']:.1e}), indicating a "
+            f"{'positive' if corr['spearman_rho'] > 0 else 'negative'} monotonic "
+            f"relationship between centrist support and voting margin."
+        )
+    else:
+        report.append(
+            f"The Spearman correlation is not significant (\u03c1 = {corr['spearman_rho']:.3f}, "
+            f"p = {corr['spearman_p']:.3f}). Centrist support alone does not predict "
+            f"voting margin."
+        )
+
+    report += [
+        "",
+        "---",
+        "",
+        "## 3. Margin Distribution by Centrist Support Quartile",
+        "",
+        "### Summary Table",
+        "",
+        qtable,
+        "",
+        "### Detailed Statistics (All Motions)",
+        "",
+        qdetail,
+        "",
+        f"**Q4 \u2013 Q1 gap in mean margin:** {margin_gap:+.3f}",
+        "",
+    ]
+
+    if not np.isnan(margin_gap) and margin_gap > 0:
+        report.append(
+            f"The gap of {margin_gap:+.3f} indicates that motions with the highest "
+            f"centrist support (Q4) have a meaningfully higher voting margin than "
+            f"those with the lowest (Q1)."
+        )
+    elif not np.isnan(margin_gap):
+        report.append(
+            f"The gap of {margin_gap:+.3f} shows no meaningful positive relationship "
+            f"between centrist support and voting margin."
+        )
+
+    report += [
+        "",
+        "---",
+        "",
+        "## 4. Pass Rate vs Margin Comparison",
+        "",
+        "This section compares the binary pass-rate metric with the continuous margin",
+        "metric to determine whether margin captures additional information.",
+        "",
+        pass_table,
+        "",
+    ]
+
+    # Check if margin detects patterns pass rate misses
+    q1_pr = 0.0
+    q4_pr = 0.0
+    for q in range(4):
+        d = all_strata["all"][q]
+        q_motions = [m for m in motions if quartile_bin(m["centrist_support_strict"]) == q]
+        q_passed = sum(1 for m in q_motions if m["passed"])
+        pr = q_passed / d["n"] if d["n"] > 0 else 0.0
+        if q == 0:
+            q1_pr = pr
+        elif q == 3:
+            q4_pr = pr
+
+    pass_gap = q4_pr - q1_pr if q4_pr > 0 else 0.0
+
+    report.append(
+        f"**Pass rate gap (Q4 \u2013 Q1):** {pass_gap:+.1%}"
+    )
+    report.append(
+        f"**Margin gap (Q4 \u2013 Q1):** {margin_gap:+.3f}"
+    )
+
+    if pass_gap < 0.05 and abs(margin_gap) > 0.05:
+        report.append("")
+        report.append(
+            "The pass rate gap is small ({:.1%}) while the margin gap is meaningful "
+            "({:+.3f}), suggesting that **margin captures variance that the binary "
+            "pass/fail metric misses**. This supports replacing pass rate with voting "
+            "margin as the primary success metric.".format(pass_gap, margin_gap)
+        )
+    elif pass_gap >= 0.05:
+        report.append("")
+        report.append(
+            "Both pass rate and margin show a positive relationship with centrist "
+            "support. Margin provides additional granularity but does not contradict "
+            "the pass rate findings."
+        )
+    else:
+        report.append("")
+        report.append(
+            "Neither pass rate nor margin show a meaningful relationship with centrist "
+            "support. The high baseline pass rate (~{:.0%}) creates a ceiling effect "
+            "for both metrics.".format(overall_pass_rate)
+        )
+
+    report += [
+        "",
+        "---",
+        "",
+        "## 5. Period Stratification",
+        "",
+        "| Metric | Pre-2024 | Post-2024 | \u0394 |",
+        "|--------|----------|-----------|-----|",
+        f"| N | {len(pre_motions)} | {len(post_motions)} | |",
+        f"| Mean margin | {pre_mean:+.3f} | {post_mean:+.3f} | {delta:+.3f} |",
+        f"| Mann-Whitney U | | | {u_str} |",
+        f"| Cohen's d | | | {cohens_d:+.3f} |" if not np.isnan(cohens_d) else "",
+        "",
+    ]
+
+    if not np.isnan(post_mean) and not np.isnan(pre_mean):
+        _, period_p = mannwhitneyu(pre_margins, post_margins, alternative="two-sided")
+        if period_p < 0.05:
+            direction = "rose" if post_mean > pre_mean else "fell"
+            report.append(
+                f"Voting margin {direction} significantly post-2024 "
+                f"(Mann-Whitney p = {period_p:.1e}, d = {cohens_d:+.3f})."
+            )
+        else:
+            report.append(
+                f"Voting margin did not change significantly between periods "
+                f"(Mann-Whitney p = {period_p:.3f})."
+            )
+
+    report += [
+        "",
+        "---",
+        "",
+        "## 6. Yearly Breakdown",
+        "",
+        ytable,
+        "",
+        "---",
+        "",
+        "## 7. Interpretation",
+        "",
+    ]
+
+    if corr["spearman_p"] < 0.05 and corr["spearman_rho"] > 0:
+        report.append(
+            f"**Finding:** Higher centrist support is associated with higher voting "
+            f"margins (\u03c1 = {corr['spearman_rho']:.3f}, p = {corr['spearman_p']:.1e}). "
+            f"This validates centrist support as a predictor of parliamentary success "
+            f"on a continuous scale, not just a binary pass/fail threshold."
+        )
+    elif corr["spearman_p"] < 0.05:
+        report.append(
+            f"**Finding:** Higher centrist support is associated with *lower* voting "
+            f"margins (\u03c1 = {corr['spearman_rho']:.3f}, p = {corr['spearman_p']:.1e}). "
+            f"This is counterintuitive and warrants further investigation."
+        )
+    else:
+        report.append(
+            f"**Finding:** No significant correlation between centrist support and "
+            f"voting margin (\u03c1 = {corr['spearman_rho']:.3f}, p = {corr['spearman_p']:.3f}). "
+        )
+
+    report.append("")
+    report.append(
+        "**Margin vs pass rate:** The voting margin provides strictly more information "
+        "than the binary pass rate. Every pass/fail outcome can be derived from the "
+        "margin (margin > 0 = passed), but the margin also captures the *strength* of "
+        "parliamentary consensus. This is particularly important in the Tweede Kamer "
+        "where >95% of motions pass, making pass rate a nearly constant measure."
+    )
+
+    report += [
+        "",
+        "---",
+        "",
+        "## 8. Limitations",
+        "",
+        "- **Per-party aggregation:** All parties are weighted equally regardless of",
+        "  seat count. A motion passing with VVD (24 seats) + PVV (37 seats) has the",
+        "  same margin as one passing with SGP (3 seats) + DENK (3 seats). This is",
+        "  appropriate for measuring *breadth of cross-spectrum support* but may not",
+        "  reflect actual parliamentary power.",
+        "- **Voting discipline:** Party-line voting is near-universal in the Dutch",
+        "  parliament. The per-party aggregation loses little information.",
+        "- **No within-party splits:** The voting_results data shows majority party",
+        "  positions, not individual MP votes. Intra-party dissent is invisible.",
+        "- **Missing data:** Motions without voting_results are excluded.",
+        "",
+        "---",
+        "",
+        f"![Figure: Voting margin analysis]({Path(fig_path).name})",
+        "",
+        "*Report generated by `analysis/right_wing/voting_margin.py`*",
+    ]
+
+    report_path = REPORTS_DIR / "voting_margin.md"
+    with open(report_path, "w") as f:
+        f.write("\n".join(report))
+    logger.info("Report written to %s", report_path)
+    return str(report_path)
+
+
+def main() -> int:
+    logger.info("Connecting to database: %s", DB_PATH)
+    con = duckdb.connect(DB_PATH, read_only=True)
+
+    logger.info("Collecting motion margins...")
+    motions = collect_motion_margins(con)
+    con.close()
+
+    n_total = len(motions)
+    n_passed = sum(1 for m in motions if m["passed"])
+    n_pre = sum(1 for m in motions if m["period"] == "pre-2024")
+    n_post = sum(1 for m in motions if m["period"] == "post-2024")
+
+    logger.info(
+        "Total: %d motions with voting data, %d passed (%.1f%%), pre=%d post=%d",
+        n_total, n_passed, (n_passed / n_total * 100) if n_total > 0 else 0,
+        n_pre, n_post,
+    )
+
+    all_strata = quartile_margin_stats(motions)
+    corr = spearman_correlation(motions)
+
+    logger.info(
+        "Spearman rho=%.3f p=%.1e | Pearson r=%.3f p=%.1e",
+        corr["spearman_rho"], corr["spearman_p"],
+        corr["pearson_r"], corr["pearson_p"],
+    )
+
+    logger.info("Generating figure...")
+    fig_path = create_figure(all_strata, motions, corr)
+
+    logger.info("Generating report...")
+    report_path = generate_report(all_strata, motions, corr, fig_path)
+
+    print(f"\nReport: {report_path}")
+    print(f"Figure: {fig_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

analysis/svd_labels.py

@@ -0,0 +1,172 @@
+"""Unified SVD component labels and automatic flip direction computation.
+
+This module provides a single source of truth for SVD component labels,
+deriving them from SVD_THEMES in explorer.py. It also computes flip
+directions automatically based on party centroids.
+"""
+
+import logging
+from typing import Dict, List, Optional, Tuple
+
+from analysis.config import CANONICAL_LEFT, CANONICAL_RIGHT
+
+_logger = logging.getLogger(__name__)
+
+RIGHT_PARTIES = CANONICAL_RIGHT
+LEFT_PARTIES = CANONICAL_LEFT
+
+# Cache for SVD_THEMES to avoid repeated imports
+_svd_themes_cache: Optional[Dict[int, Dict[str, str]]] = None
+
+
+def _get_svd_themes() -> Dict[int, Dict[str, str]]:
+    """Import SVD_THEMES from explorer.py.
+
+    Returns:
+        Dict mapping component number to theme dict with keys:
+        - label: Short label for the component
+        - explanation: Detailed explanation
+        - positive_pole: Description of positive pole
+        - negative_pole: Description of negative pole
+        - flip: Whether to flip the axis
+    """
+    global _svd_themes_cache
+    if _svd_themes_cache is not None:
+        return _svd_themes_cache
+
+    # Prefer the lightweight canonical source in analysis.config which is
+    # intentionally free of heavy runtime dependencies. Fall back to
+    # explorer.SVD_THEMES only when the config module is unavailable or
+    # doesn't expose SVD_THEMES.
+    try:
+        from analysis import config as _cfg
+
+        _svd_themes_cache = getattr(_cfg, "SVD_THEMES", {}) or {}
+        if _svd_themes_cache:
+            return _svd_themes_cache
+    except Exception:
+        _logger.exception(
+            "Could not import analysis.config or read SVD_THEMES; falling back to explorer"
+        )
+
+    try:
+        # Import explorer at runtime as a last resort; explorer may pull in
+        # heavy dependencies (duckdb/plotly) so we only try this if config
+        # didn't provide the themes.
+        import explorer
+
+        _svd_themes_cache = getattr(explorer, "SVD_THEMES", {}) or {}
+        return _svd_themes_cache
+    except ImportError as e:
+        _logger.warning("Could not import explorer.SVD_THEMES: %s", e)
+        return {}
+    except Exception as e:
+        _logger.exception("Failed to load SVD_THEMES from explorer.py: %s", e)
+        return {}
+
+
+def get_svd_label(component: int) -> str:
+    """Get short label for SVD component.
+
+    Args:
+        component: SVD component number (1-indexed)
+
+    Returns:
+        Short label string (e.g., 'EU-integratie–Nationalisme')
+
+    Raises:
+        ValueError: If component < 1
+    """
+    if component < 1:
+        raise ValueError(f"Component must be >= 1, got {component}")
+
+    themes = _get_svd_themes()
+    if component in themes:
+        return themes[component].get("label", f"As {component}")
+
+    # Fallback labels for components 1-3 (most commonly used)
+    fallback_labels = {
+        1: "EU-integratie–Nationalisme",
+        2: "Populistisch–Institutioneel",
+        3: "Verzorgingsstaat–Marktwerking",
+    }
+    return fallback_labels.get(component, f"As {component}")
+
+
+def get_svd_theme(component: int) -> Dict[str, str]:
+    """Get full theme dict for SVD component.
+
+    Args:
+        component: SVD component number (1-indexed)
+
+    Returns:
+        Dict with keys: label, explanation, positive_pole, negative_pole, flip
+    """
+    if component < 1:
+        raise ValueError(f"Component must be >= 1, got {component}")
+
+    themes = _get_svd_themes()
+    if component in themes:
+        return themes[component]
+
+    # Return minimal fallback
+    return {
+        "label": get_svd_label(component),
+        "explanation": "",
+        "positive_pole": "",
+        "negative_pole": "",
+        "flip": False,
+    }
+
+
+def compute_flip_direction(
+    component: int,
+    party_scores: Dict[str, List[float]],
+) -> bool:
+    """Compute flip direction so right parties appear on the right side.
+
+    Args:
+        component: SVD component number (1-indexed)
+        party_scores: Dict mapping party name to per-component scores.
+                      party_scores[party][0] is score for component 1 (x-axis),
+                      party_scores[party][1] is score for component 2 (y-axis).
+
+    Returns:
+        True if axis should be flipped so right parties are on right.
+        False otherwise.
+    """
+    if component < 1:
+        return False
+
+    idx = component - 1  # Convert to 0-indexed
+
+    right_scores = []
+    left_scores = []
+
+    for party, scores in party_scores.items():
+        if len(scores) <= idx:
+            continue
+
+        score = scores[idx]
+        if party in RIGHT_PARTIES:
+            right_scores.append(score)
+        elif party in LEFT_PARTIES:
+            left_scores.append(score)
+
+    if not right_scores or not left_scores:
+        return False  # Default: no flip if insufficient data
+
+    right_mean = sum(right_scores) / len(right_scores)
+    left_mean = sum(left_scores) / len(left_scores)
+
+    # Flip if right parties have lower mean (they're on the left)
+    return right_mean < left_mean
+
+
+def get_fallback_labels() -> Tuple[str, str]:
+    """Get fallback labels for x and y axes (components 1 and 2).
+
+    Returns:
+        Tuple of (x_label, y_label)
+    """
+    return (get_svd_label(1), get_svd_label(2))

analysis/tabs/__init__.py

@@ -0,0 +1,19 @@
+"""Tab modules for the parliamentary explorer.
+
+This package contains tab-building functions extracted from explorer.py.
+Each module contains a `build_<tab>_tab()` function that implements one tab.
+"""
+
+from analysis.tabs.compass import build_compass_tab
+from analysis.tabs.trajectories import build_trajectories_tab
+from analysis.tabs.components import build_svd_components_tab
+from analysis.tabs.quiz import build_mp_quiz_tab
+from analysis.tabs.overton import build_overton_tab
+
+__all__ = [
+    "build_compass_tab",
+    "build_trajectories_tab",
+    "build_svd_components_tab",
+    "build_mp_quiz_tab",
+    "build_overton_tab",
+]

analysis/tabs/_rendering.py

@@ -0,0 +1,797 @@
+"""Rendering helpers for explorer tabs.
+
+This module contains all Plotly/Streamlit rendering functions extracted from
+explorer.py.  It is import-safe: plotly and streamlit are optional.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Dict, List, Optional, Tuple
+
+try:
+    import plotly.express as px
+    import plotly.graph_objects as go
+except Exception:
+    px = None
+    import types
+
+    class _DummyTrace:
+        def __init__(self, **kwargs):
+            self.name = kwargs.get("name")
+            self.x = kwargs.get("x")
+            self.y = kwargs.get("y")
+            self.text = kwargs.get("text")
+            self.customdata = kwargs.get("customdata")
+
+    class _DummyFigure:
+        def __init__(self):
+            self.data = []
+
+        def add_trace(self, trace):
+            if isinstance(trace, _DummyTrace):
+                self.data.append(trace)
+            else:
+                try:
+                    name = getattr(trace, "name", None)
+                    x = getattr(trace, "x", None)
+                    y = getattr(trace, "y", None)
+                    text = getattr(trace, "text", None)
+                    customdata = getattr(trace, "customdata", None)
+                except Exception:
+                    name = trace.get("name") if hasattr(trace, "get") else None
+                    x = trace.get("x") if hasattr(trace, "get") else None
+                    y = trace.get("y") if hasattr(trace, "get") else None
+                    text = trace.get("text") if hasattr(trace, "get") else None
+                    customdata = (
+                        trace.get("customdata") if hasattr(trace, "get") else None
+                    )
+                self.data.append(
+                    _DummyTrace(name=name, x=x, y=y, text=text, customdata=customdata)
+                )
+
+        def add_annotation(self, *args, **kwargs):
+            return None
+
+        def update_layout(self, **kwargs):
+            return None
+
+        def update_traces(self, **kwargs):
+            return None
+
+        def add_hline(self, **kwargs):
+            return None
+
+    go = types.SimpleNamespace(
+        Figure=_DummyFigure,
+        Scatter=lambda **kwargs: _DummyTrace(**kwargs),
+        Bar=lambda **kwargs: _DummyTrace(**kwargs),
+    )
+
+try:
+    import streamlit as st
+except Exception:
+
+    class _DummySt:
+        def cache_data(self, *args, **kwargs):
+            def _decorator(func):
+                return func
+
+            return _decorator
+
+        def markdown(self, *args, **kwargs):
+            return None
+
+        def subheader(self, *args, **kwargs):
+            return None
+
+        def plotly_chart(self, *args, **kwargs):
+            return None
+
+        def caption(self, *args, **kwargs):
+            return None
+
+        def text_area(self, *args, **kwargs):
+            return None
+
+        def json(self, *args, **kwargs):
+            return None
+
+        def checkbox(self, *args, **kwargs):
+            return kwargs.get("value", False)
+
+        def warning(self, *args, **kwargs):
+            return None
+
+        def info(self, *args, **kwargs):
+            return None
+
+        def error(self, *args, **kwargs):
+            return None
+
+        def success(self, *args, **kwargs):
+            return None
+
+        def selectbox(self, *args, **kwargs):
+            opts = (
+                kwargs.get("options")
+                if kwargs.get("options") is not None
+                else (args[1] if len(args) > 1 else [])
+            )
+            return opts[0] if opts else None
+
+        def multiselect(self, *args, **kwargs):
+            opts = (
+                kwargs.get("options")
+                if kwargs.get("options") is not None
+                else (args[1] if len(args) > 1 else [])
+            )
+            default = kwargs.get("default")
+            if default is not None:
+                return default
+            return opts[:6] if opts else []
+
+        def number_input(self, *args, **kwargs):
+            return kwargs.get("value") if "value" in kwargs else 1
+
+        def slider(self, *args, **kwargs):
+            return kwargs.get("value") if "value" in kwargs else 0.35
+
+        def select_slider(self, *args, **kwargs):
+            return kwargs.get("value") if "value" in kwargs else (None, None)
+
+        def expander(self, *args, **kwargs):
+            class _Ctx:
+                def __enter__(self_inner):
+                    return self_inner
+
+                def __exit__(self_inner, exc_type, exc, tb):
+                    return False
+
+            return _Ctx()
+
+        def columns(self, *args, **kwargs):
+            class _Col:
+                def markdown(self, *a, **k):
+                    return None
+
+                def metric(self, *a, **k):
+                    return None
+
+                def dataframe(self, *a, **k):
+                    return None
+
+                def write(self, *a, **k):
+                    return None
+
+                def text_input(self, *a, **k):
+                    return None
+
+            n = len(args[0]) if args else 1
+            return tuple(_Col() for _ in range(n))
+
+        def form(self, *args, **kwargs):
+            class _Ctx:
+                def __enter__(self_inner):
+                    return self_inner
+
+                def __exit__(self_inner, exc_type, exc, tb):
+                    return False
+
+            return _Ctx()
+
+        def form_submit_button(self, *args, **kwargs):
+            return False
+
+        def button(self, *args, **kwargs):
+            return False
+
+        def rerun(self, *args, **kwargs):
+            return None
+
+        def divider(self, *args, **kwargs):
+            return None
+
+        def spinner(self, *args, **kwargs):
+            class _Ctx:
+                def __enter__(self_inner):
+                    return self_inner
+
+                def __exit__(self_inner, exc_type, exc, tb):
+                    return False
+
+            return _Ctx()
+
+        def write(self, *args, **kwargs):
+            return None
+
+        def dataframe(self, *args, **kwargs):
+            return None
+
+        def set_page_config(self, *args, **kwargs):
+            return None
+
+        def title(self, *args, **kwargs):
+            return None
+
+        def sidebar(self, *args, **kwargs):
+            return self
+
+        def radio(self, *args, **kwargs):
+            return kwargs.get("value") if "value" in kwargs else None
+
+        def text_input(self, *args, **kwargs):
+            return kwargs.get("value", "")
+
+        def tabs(self, *args, **kwargs):
+            n = len(args[0]) if args else 1
+            return [self for _ in range(n)]
+
+        @property
+        def session_state(self):
+            if not hasattr(self, "_session_state"):
+                self._session_state = {}
+            return self._session_state
+
+    st = _DummySt()
+
+from analysis.config import PARTY_COLOURS
+
+logger = logging.getLogger(__name__)
+
+
+def _render_scree_plot(importances: List[float], n_show: int = 15) -> None:
+    """Render a scree plot showing relative SVD component importance.
+
+    Highlighted bars for the top-2 components (used in the compass); muted bars
+    for the rest.  A cumulative-variance dashed line on the same y-axis helps
+    spot the elbow.  A 50 % cumulative threshold line is drawn for reference.
+
+    Args:
+        importances: List of importance values sorted descending (from load_scree_data).
+        n_show: How many components to display (default: first 15).
+    """
+    if not importances:
+        return
+    data = list(importances[:n_show])
+    ranks = list(range(1, len(data) + 1))
+
+    cumsum = []
+    running = 0.0
+    for v in data:
+        running += v
+        cumsum.append(running)
+
+    n_highlight = 2
+    bar_colours = [
+        "#1565C0" if i < n_highlight else "#90CAF9" for i in range(len(data))
+    ]
+
+    fig = go.Figure()
+
+    fig.add_trace(
+        go.Bar(
+            x=ranks,
+            y=data,
+            marker_color=bar_colours,
+            hovertemplate="As %{x}<br><b>%{y:.1f}%</b> verklaarde variantie<extra></extra>",
+            showlegend=False,
+        )
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=ranks,
+            y=cumsum,
+            mode="lines+markers",
+            line={"color": "#F57C00", "width": 2, "dash": "dot"},
+            marker={"size": 5, "color": "#F57C00"},
+            hovertemplate="As %{x}<br>Cumulatief: <b>%{y:.1f}%</b><extra></extra>",
+            name="Cumulatief",
+            showlegend=True,
+        )
+    )
+
+    fig.add_hline(
+        y=50,
+        line_dash="dash",
+        line_color="#BDBDBD",
+        line_width=1,
+        annotation_text="50%",
+        annotation_position="right",
+        annotation_font_color="#9E9E9E",
+        annotation_font_size=11,
+    )
+
+    for i in range(min(n_highlight, len(data))):
+        fig.add_annotation(
+            x=ranks[i],
+            y=data[i] + 0.3,
+            text=f"{data[i]:.1f}%",
+            showarrow=False,
+            font={"size": 11, "color": "#1565C0"},
+            yanchor="bottom",
+        )
+
+    fig.update_layout(
+        height=280,
+        margin={"l": 10, "r": 50, "t": 30, "b": 40},
+        title={
+            "text": "Belang per SVD-as",
+            "font": {"size": 13, "color": "#555555"},
+            "x": 0.02,
+            "xanchor": "left",
+        },
+        legend={
+            "orientation": "h",
+            "x": 0.5,
+            "xanchor": "center",
+            "y": 1.08,
+            "font": {"size": 11},
+        },
+        xaxis={
+            "title": {"text": "As (rang)", "font": {"size": 11}},
+            "tickmode": "linear",
+            "tick0": 1,
+            "dtick": 1,
+            "showline": False,
+            "showgrid": False,
+        },
+        yaxis={
+            "title": {"text": "% van totale variantie", "font": {"size": 11}},
+            "showline": False,
+            "showgrid": True,
+            "gridcolor": "#eeeeee",
+            "ticksuffix": "%",
+            "range": [0, max(cumsum) * 1.08],
+        },
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+        bargap=0.25,
+    )
+    st.plotly_chart(fig, use_container_width=True)
+
+
+def _build_party_axis_figure(
+    party_coords: Dict[str, Tuple[float, float]],
+    comp_sel: int,
+    theme: dict,
+    bootstrap_data: Optional[Dict[str, Dict]] = None,
+) -> Optional[go.Figure]:
+    """Build a 1D horizontal Plotly scatter of party positions on SVD axis `comp_sel`.
+
+    Accepts explicit per-party 2D coordinates (x,y) and uses the component selection to
+    pick the value (comp_sel==1 -> x, comp_sel==2 -> y). This makes the API explicit and
+    avoids indexing into long SVD vectors.
+
+    Returns go.Figure or None if no data available.
+    """
+    if not party_coords:
+        return None
+
+    if comp_sel not in (1, 2):
+        raise ValueError(
+            "_build_party_axis_figure only supports comp_sel 1 or 2 when using explicit coords"
+        )
+
+    axis_idx = comp_sel - 1
+    flip = theme.get("flip", False)
+
+    parties = []
+    scores = []
+    colours = []
+
+    for party, val in party_coords.items():
+        try:
+            if hasattr(val, "__len__") and len(val) == 2:
+                x, y = val
+                score = float(x if axis_idx == 0 else y)
+            else:
+                score = float(val[axis_idx])
+
+            if flip:
+                score = -score
+        except Exception:
+            continue
+
+        parties.append(party)
+        scores.append(score)
+        colours.append(PARTY_COLOURS.get(party, "#9E9E9E"))
+
+    if not scores:
+        return None
+
+    hover = []
+    symbols = []
+    if bootstrap_data:
+        for p, s in zip(parties, scores):
+            bd = bootstrap_data.get(p)
+            if bd:
+                n_mps = bd.get("n_mps", "?")
+                ci_low = None
+                ci_high = None
+                try:
+                    ci_low = float(bd["ci_lower"][axis_idx])
+                    ci_high = float(bd["ci_upper"][axis_idx])
+                except Exception:
+                    pass
+                if ci_low is not None and ci_high is not None:
+                    hover.append(
+                        f"{p}: {s:.3f} (N={n_mps}, 95%-BI: [{ci_low:.3f}, {ci_high:.3f}])"
+                    )
+                else:
+                    hover.append(f"{p}: {s:.3f} (N={n_mps})")
+                symbols.append("diamond" if n_mps == 1 else "circle")
+            else:
+                hover.append(f"{p}: {s:.3f}")
+                symbols.append("circle")
+        marker_kwargs = {"size": 14, "color": colours, "symbol": symbols}
+    else:
+        hover = [f"{p}: {s:.3f}" for p, s in zip(parties, scores)]
+        marker_kwargs = {"size": 14, "color": colours}
+
+    fig = go.Figure()
+    x_min, x_max = min(scores) * 1.15, max(scores) * 1.15
+    if x_min == x_max:
+        x_min, x_max = x_min - 1, x_max + 1
+    fig.add_trace(
+        go.Scatter(
+            x=[x_min, x_max],
+            y=[0, 0],
+            mode="lines",
+            line={"color": "#cccccc", "width": 1},
+            hoverinfo="skip",
+            showlegend=False,
+        )
+    )
+
+    scatter_kwargs = {
+        "x": scores,
+        "y": [0] * len(scores),
+        "mode": "markers+text",
+        "text": parties,
+        "textposition": "top center",
+        "marker": marker_kwargs,
+        "hovertext": hover,
+        "hoverinfo": "text",
+        "showlegend": False,
+    }
+    fig.add_trace(go.Scatter(**scatter_kwargs))
+
+    pos_pole = theme.get("positive_pole", "")
+    neg_pole = theme.get("negative_pole", "")
+    left_label = neg_pole
+    right_label = pos_pole
+
+    fig.update_layout(
+        height=160,
+        margin={"l": 10, "r": 10, "t": 10, "b": 30},
+        xaxis={
+            "title": f"← {left_label}  |  {right_label} →",
+            "showticklabels": False,
+            "showline": False,
+            "showgrid": False,
+            "zeroline": False,
+        },
+        yaxis={"visible": False, "range": [-1, 2]},
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+    )
+    return fig
+
+
+def _render_party_axis_chart(
+    party_coords: Dict[str, Tuple[float, float]],
+    comp_sel: int,
+    theme: dict,
+    bootstrap_data: Optional[Dict[str, Dict]] = None,
+) -> None:
+    """Render a 1D horizontal Plotly scatter of party positions on SVD axis `comp_sel`.
+
+    Expects explicit per-party coords mapping (party -> (x,y)) for components 1 & 2.
+    """
+    fig = _build_party_axis_figure(party_coords, comp_sel, theme, bootstrap_data)
+    if fig is None:
+        st.caption("_Partijdata niet beschikbaar voor deze as._")
+        return
+    st.plotly_chart(fig, use_container_width=True)
+
+
+def _render_party_axis_chart_1d(
+    party_coords: Dict[str, Tuple[float, ...]],
+    comp_sel: int,
+    theme: dict,
+) -> None:
+    """Render a 1D horizontal scatter of party positions on SVD component `comp_sel`.
+
+    Uses the same format as components 1-2: parties as markers on a horizontal line
+    with axis title showing poles with arrows.
+
+    Args:
+        party_coords: Dict mapping party name to tuple of scores (score_for_comp,)
+        comp_sel: SVD component number (1-indexed)
+        theme: Dict with label, positive_pole, negative_pole, flip
+    """
+    if not party_coords:
+        st.caption("_Partijdata niet beschikbaar voor deze as._")
+        return
+
+    parties = []
+    scores = []
+    colours = []
+
+    for party, coords in party_coords.items():
+        try:
+            score = float(coords[0])
+            parties.append(party)
+            scores.append(score)
+            colours.append(PARTY_COLOURS.get(party, "#9E9E9E"))
+        except Exception:
+            continue
+
+    if not scores:
+        st.caption("_Partijdata niet beschikbaar voor deze as._")
+        return
+
+    flip = theme.get("flip", False)
+    if flip:
+        scores = [-s for s in scores]
+
+    hover = [f"{p}: {s:.3f}" for p, s in zip(parties, scores)]
+
+    fig = go.Figure()
+    x_min, x_max = min(scores) * 1.15, max(scores) * 1.15
+    if x_min == x_max:
+        x_min, x_max = x_min - 1, x_max + 1
+
+    fig.add_trace(
+        go.Scatter(
+            x=[x_min, x_max],
+            y=[0, 0],
+            mode="lines",
+            line={"color": "#cccccc", "width": 1},
+            hoverinfo="skip",
+            showlegend=False,
+        )
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=scores,
+            y=[0] * len(scores),
+            mode="markers+text",
+            text=parties,
+            textposition="top center",
+            marker={"size": 14, "color": colours},
+            hovertext=hover,
+            hoverinfo="text",
+            showlegend=False,
+        )
+    )
+
+    pos_pole = theme.get("positive_pole", "")
+    neg_pole = theme.get("negative_pole", "")
+    left_label = neg_pole
+    right_label = pos_pole
+
+    fig.update_layout(
+        height=160,
+        margin={"l": 10, "r": 10, "t": 10, "b": 30},
+        xaxis={
+            "title": f"← {left_label}  |  {right_label} →",
+            "showticklabels": False,
+            "showline": False,
+            "showgrid": False,
+            "zeroline": False,
+        },
+        yaxis={"visible": False, "range": [-1, 2]},
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+
+def _render_svd_time_trajectory(
+    party_scores_by_window: Dict[str, Dict[str, List[float]]],
+    comp_sel: int,
+    theme: dict,
+    selected_parties: List[str],
+) -> None:
+    """Render a time trajectory plot showing party positions over time on an SVD component.
+
+    Args:
+        party_scores_by_window: {window_id: {party_name: [scores]}}
+        comp_sel: SVD component number (1-indexed)
+        theme: Theme dict with label, positive_pole, negative_pole, flip
+        selected_parties: List of party names to display
+    """
+    if not party_scores_by_window or not selected_parties:
+        st.caption("_Geen data beschikbaar voor tijdtraject._")
+        return
+
+    idx = comp_sel - 1
+    flip = theme.get("flip", False)
+
+    party_trajectories: Dict[str, List[Tuple[str, float]]] = {}
+
+    all_windows = list(party_scores_by_window.keys())
+    sorted_windows = []
+    if "current_parliament" in all_windows:
+        sorted_windows.append("current_parliament")
+    other_windows = sorted(
+        [w for w in all_windows if w != "current_parliament"], reverse=True
+    )
+    sorted_windows.extend(other_windows)
+
+    for window in sorted_windows:
+        scores_by_party = party_scores_by_window.get(window, {})
+        for party in selected_parties:
+            scores = scores_by_party.get(party, [])
+            if scores and len(scores) > idx:
+                try:
+                    score = float(scores[idx])
+                    if flip:
+                        score = -score
+                    party_trajectories.setdefault(party, []).append((window, score))
+                except (ValueError, TypeError):
+                    continue
+
+    if not party_trajectories:
+        st.caption("_Geen data beschikbaar voor geselecteerde partijen._")
+        return
+
+    fig = go.Figure()
+
+    all_scores = []
+    for traj in party_trajectories.values():
+        all_scores.extend([s for _, s in traj])
+
+    if not all_scores:
+        st.caption("_Geen scores beschikbaar._")
+        return
+
+    x_min, x_max = min(all_scores) * 1.15, max(all_scores) * 1.15
+    if x_min == x_max:
+        x_min, x_max = x_min - 1, x_max + 1
+
+    window_to_y = {w: i for i, w in enumerate(sorted_windows)}
+
+    for window in sorted_windows:
+        y_pos = window_to_y[window]
+        fig.add_trace(
+            go.Scatter(
+                x=[x_min, x_max],
+                y=[y_pos, y_pos],
+                mode="lines",
+                line={"color": "#cccccc", "width": 1},
+                hoverinfo="skip",
+                showlegend=False,
+            )
+        )
+
+    for party in selected_parties:
+        if party not in party_trajectories:
+            continue
+
+        traj = party_trajectories[party]
+        if len(traj) < 1:
+            continue
+
+        x_vals = [score for _, score in traj]
+        y_vals = [window_to_y[window] for window, _ in traj]
+        color = PARTY_COLOURS.get(party, "#9E9E9E")
+
+        fig.add_trace(
+            go.Scatter(
+                x=x_vals,
+                y=y_vals,
+                mode="lines",
+                line={"color": color, "width": 2},
+                hoverinfo="skip",
+                showlegend=False,
+            )
+        )
+
+        hover_texts = [f"{party}<br>{window}: {score:.3f}" for window, score in traj]
+        fig.add_trace(
+            go.Scatter(
+                x=x_vals,
+                y=y_vals,
+                mode="markers+text",
+                text=[party] * len(traj),
+                textposition="top center",
+                marker={"size": 12, "color": color},
+                hovertext=hover_texts,
+                hoverinfo="text",
+                showlegend=False,
+            )
+        )
+
+    pos_pole = theme.get("positive_pole", "")
+    neg_pole = theme.get("negative_pole", "")
+    left_label = neg_pole
+    right_label = pos_pole
+
+    y_labels = {}
+    for window in sorted_windows:
+        if window == "current_parliament":
+            y_labels[window_to_y[window]] = "Huidig"
+        else:
+            y_labels[window_to_y[window]] = window
+
+    fig.update_layout(
+        height=max(400, len(sorted_windows) * 60 + 100),
+        margin={"l": 80, "r": 10, "t": 10, "b": 30},
+        xaxis={
+            "title": f"← {left_label}  |  {right_label} →",
+            "range": [x_min, x_max],
+            "showticklabels": False,
+            "showline": False,
+            "showgrid": True,
+            "gridcolor": "rgba(0,0,0,0.1)",
+            "zeroline": True,
+            "zerolinecolor": "rgba(0,0,0,0.2)",
+        },
+        yaxis={
+            "tickvals": list(y_labels.keys()),
+            "ticktext": list(y_labels.values()),
+            "tickmode": "array",
+            "autorange": "reversed",
+            "showgrid": False,
+        },
+        plot_bgcolor="rgba(0,0,0,0)",
+        paper_bgcolor="rgba(0,0,0,0)",
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+
+def _render_voting_results(voting_results_json) -> None:
+    """Render a voting_results JSON blob as a grouped voor/tegen/onthouden table.
+
+    The JSON is stored as {party_or_mp: vote} where vote is one of
+    'voor', 'tegen', 'onthouden', 'afwezig'. We group by vote for readability.
+    """
+    if not voting_results_json:
+        return
+    try:
+        vdata = (
+            json.loads(voting_results_json)
+            if isinstance(voting_results_json, str)
+            else voting_results_json
+        )
+        if not isinstance(vdata, dict) or not vdata:
+            return
+        by_vote: Dict[str, List[str]] = {}
+        for actor, vote in vdata.items():
+            vote_str = str(vote).lower().strip()
+            by_vote.setdefault(vote_str, []).append(str(actor))
+        vote_order = ["voor", "tegen", "onthouden", "afwezig"]
+        rows_shown = False
+        for v in vote_order + [k for k in by_vote if k not in vote_order]:
+            actors = by_vote.get(v)
+            if not actors:
+                continue
+            st.markdown(
+                f"**{v.capitalize()}** ({len(actors)}): {', '.join(sorted(actors))}"
+            )
+            rows_shown = True
+        if not rows_shown:
+            st.caption("_Geen stemuitslag beschikbaar_")
+    except Exception:
+        pass
+
+
+def _add_y_direction_annotations(fig: go.Figure) -> None:
+    """Add Progressief / Conservatief labels above and below the Y axis."""
+    common = dict(
+        xref="paper",
+        yref="paper",
+        x=-0.07,
+        showarrow=False,
+        font=dict(size=11, color="#666666"),
+    )
+    fig.add_annotation(**common, y=1.02, text="Progressief", xanchor="center")
+    fig.add_annotation(**common, y=-0.06, text="Conservatief", xanchor="center")

analysis/tabs/browser.py

@@ -0,0 +1,95 @@
+"""Browser tab for the parliamentary explorer."""
+
+from __future__ import annotations
+
+import pandas as pd
+
+import analysis.explorer_data as explorer_data
+from analysis.tabs._rendering import _render_voting_results, st
+
+
+def build_browser_tab(db_path: str, show_rejected: bool) -> None:
+    """Build the Motie Browser tab."""
+    st.subheader("Motie Browser")
+
+    df = explorer_data.load_motions_df(db_path)
+    if df.empty:
+        st.warning("Geen moties beschikbaar.")
+        return
+
+    if not show_rejected:
+        df = df[df["title"].fillna("").str.strip() != "Verworpen."]
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        years = sorted(df["year"].dropna().astype(int).unique().tolist())
+        year_filter = st.selectbox("Jaar", ["(Alle)"] + [str(y) for y in years])
+    with col2:
+        min_controversy_b = st.slider(
+            "Min. controverse",
+            min_value=0.0,
+            max_value=1.0,
+            value=0.0,
+            step=0.05,
+            key="browser_controversy",
+        )
+    with col3:
+        sort_by = st.selectbox("Sorteren op", ["Datum (nieuw)", "Controverse", "Marge"])
+
+    working = df.copy()
+    if year_filter != "(Alle)":
+        working = working[working["year"] == int(year_filter)]
+    if min_controversy_b > 0:
+        working = working[working["controversy_score"] >= min_controversy_b]
+
+    sort_map = {
+        "Datum (nieuw)": ("date", False),
+        "Controverse": ("controversy_score", False),
+        "Marge": ("winning_margin", True),
+    }
+    sort_col, sort_asc = sort_map[sort_by]
+    working = working.sort_values(by=sort_col, ascending=sort_asc)
+
+    display_cols = ["id", "title", "date", "controversy_score", "winning_margin"]
+    available_display = [c for c in display_cols if c in working.columns]
+    st.dataframe(
+        working[available_display].reset_index(drop=True),
+        use_container_width=True,
+        height=350,
+    )
+
+    st.divider()
+
+    st.markdown("**Detail weergave** — vul een motie-ID in:")
+    sel_id = st.number_input(
+        "Motie ID",
+        min_value=int(working["id"].min()) if not working.empty else 1,
+        max_value=int(working["id"].max()) if not working.empty else 99999,
+        value=int(working["id"].iloc[0]) if not working.empty else 1,
+        step=1,
+    )
+    motion_row = df[df["id"] == sel_id]
+    if not motion_row.empty:
+        row = motion_row.iloc[0]
+        st.markdown(f"### {row.get('title') or 'Onbekend'}")
+        date_str = row["date"].strftime("%d %b %Y") if pd.notna(row["date"]) else "?"
+        st.caption(
+            f"{date_str}  |  Controverse: {row.get('controversy_score', 0):.2f}"
+        )
+
+        url = row.get("url")
+        if url and str(url).startswith("http"):
+            st.markdown(f"[Bekijk op Tweede Kamer]({url})")
+
+        st.markdown("**Stemuitslag:**")
+        _render_voting_results(row.get("voting_results"))
+
+        sim = explorer_data.query_similar(db_path, int(sel_id), top_k=10)
+        if not sim.empty:
+            st.markdown("**Vergelijkbare moties:**")
+            st.dataframe(
+                sim[["title", "score", "date", "policy_area"]],
+                use_container_width=True,
+            )
+        else:
+            st.caption("_Nog geen vergelijkbare moties beschikbaar voor deze motie_")

analysis/tabs/compass.py

@@ -0,0 +1,209 @@
+"""Compass tab for the parliamentary explorer."""
+
+from __future__ import annotations
+
+import datetime as _dt
+import re
+from typing import Dict, Tuple
+
+import numpy as np
+import pandas as pd
+
+from analysis import config
+import analysis.explorer_data as explorer_data
+from analysis.tabs._rendering import px, st
+
+PARTY_COLOURS = config.PARTY_COLOURS
+
+
+def build_compass_tab(db_path: str, window_size: str) -> None:
+    """Build the Politiek Kompas tab."""
+    st.subheader("Politiek Kompas")
+    st.markdown(
+        "2D projectie van Kamerlid posities op basis van stemgedrag (PCA op SVD-vectoren)."
+    )
+
+    # Compass always uses annual windows regardless of the sidebar window_size setting.
+    positions_by_window, axis_def = explorer_data.load_positions(db_path, "annual")
+    if axis_def is None:
+        axis_def = {}
+    if not positions_by_window:
+        st.warning(
+            "Geen positiedata beschikbaar. Controleer of de pipeline is gedraaid."
+        )
+        return
+
+    party_map = explorer_data.load_party_map(db_path)
+    active_mps = explorer_data.load_active_mps(db_path)
+
+    _current_year = str(_dt.date.today().year)
+    year_windows = sorted(
+        w
+        for w in positions_by_window
+        if w != "current_parliament" and w != _current_year
+    )
+    has_current = "current_parliament" in positions_by_window
+    windows = year_windows + (["current_parliament"] if has_current else [])
+
+    _SPARSE_YEARS = {"2016", "2017", "2018"}
+    _THRESHOLD = 0.65
+
+    def _window_label(w: str) -> str:
+        if w == "current_parliament":
+            return "Huidig parlement"
+        return w
+
+    col1, col2 = st.columns([3, 1])
+    with col2:
+        window_idx = st.selectbox(
+            "Jaar",
+            options=windows,
+            index=len(windows) - 1,
+            format_func=_window_label,
+        )
+        level = st.radio(
+            "Weergave",
+            options=["Kamerleden", "Partijen"],
+            index=0,
+            horizontal=True,
+        )
+        min_mps = st.number_input(
+            "Min. Kamerleden per partij",
+            min_value=1,
+            max_value=20,
+            value=3,
+            step=1,
+            help="Partijen met minder dan dit aantal zetels worden niet weergegeven.",
+        )
+
+    pos = positions_by_window.get(window_idx, {})
+    if not pos:
+        st.info(f"Geen data voor venster {window_idx}")
+        return
+
+    if window_idx == "current_parliament":
+        pos = {mp: xy for mp, xy in pos.items() if mp in active_mps}
+
+    def _strip_paren(name: str) -> str:
+        return re.sub(r"\s*\([^)]*\)", "", name).strip()
+
+    deduped: Dict[str, Tuple[float, float]] = {}
+    for name, (x, y) in pos.items():
+        base = _strip_paren(name)
+        if base in deduped:
+            ox, oy = deduped[base]
+            deduped[base] = ((ox + x) / 2, (oy + y) / 2)
+        else:
+            deduped[base] = (x, y)
+    pos = deduped
+
+    rows = []
+    for name, (x, y) in pos.items():
+        party = party_map.get(name) or party_map.get(_strip_paren(name), "Unknown")
+        rows.append({"name": name, "x": x, "y": y, "party": party})
+
+    df_pos = pd.DataFrame(rows)
+
+    party_counts = df_pos[df_pos["party"] != "Unknown"]["party"].value_counts()
+    valid_parties = set(party_counts[party_counts >= min_mps].index)
+    df_pos = df_pos[df_pos["party"].isin(valid_parties)]
+
+    if df_pos.empty:
+        st.info("Geen partijen met genoeg Kamerleden voor dit venster.")
+        return
+
+    _raw_x = axis_def.get("x_label")
+    _raw_y = axis_def.get("y_label")
+
+    try:
+        from analysis.axis_classifier import display_label_for_modal
+
+        _x_label = display_label_for_modal(_raw_x, "x")
+        _y_label = display_label_for_modal(_raw_y, "y")
+    except Exception:
+        from analysis.svd_labels import get_fallback_labels
+
+        _x_fallback, _y_fallback = get_fallback_labels()
+        _x_label = _raw_x or _x_fallback
+        _y_label = _raw_y or _y_fallback
+
+    if level == "Partijen":
+        df_party = df_pos.groupby("party", as_index=False).agg(
+            x=("x", "mean"), y=("y", "mean"), n=("name", "count")
+        )
+        df_party["name"] = df_party["party"]
+        colour_map = {
+            p: PARTY_COLOURS.get(p, "#9E9E9E") for p in df_party["party"].unique()
+        }
+        fig = px.scatter(
+            df_party,
+            x="x",
+            y="y",
+            color="party",
+            text="party",
+            hover_name="party",
+            hover_data={"party": False, "x": ":.3f", "y": ":.3f", "n": True},
+            color_discrete_map=colour_map,
+            title=f"Politiek Kompas — {_window_label(window_idx)} (partijen)",
+            labels={
+                "x": _x_label,
+                "y": _y_label,
+                "n": "Kamerleden",
+            },
+        )
+        fig.update_traces(textposition="top center", marker_size=14)
+    else:
+        colour_map = {
+            p: PARTY_COLOURS.get(p, "#9E9E9E") for p in df_pos["party"].unique()
+        }
+        fig = px.scatter(
+            df_pos,
+            x="x",
+            y="y",
+            color="party",
+            hover_name="name",
+            hover_data={"party": True, "x": ":.3f", "y": ":.3f"},
+            color_discrete_map=colour_map,
+            title=f"Politiek Kompas — {_window_label(window_idx)}",
+            labels={"x": _x_label, "y": _y_label},
+        )
+
+    fig.update_layout(
+        height=600,
+        legend_title_text="Partij",
+        xaxis={"range": [-1, 1]},
+        yaxis={"range": [-0.6, 0.6]},
+    )
+    with col1:
+        st.plotly_chart(fig, use_container_width=True)
+        _x_interp = axis_def.get("x_interpretation", {}).get(window_idx, "")
+        if (
+            _x_interp
+            and axis_def.get("x_quality", {}).get(window_idx, 1.0) < _THRESHOLD
+        ):
+            st.caption(_x_interp)
+
+        with st.expander("Overton Window Context"):
+            st.markdown(
+                "The SVD compass reflects changes in voting patterns after 2024.\n\n"
+                "Centrist support for right-wing motions rose from 25% to 51%, "
+                "while support for left-wing motions stayed flat.\n\n"
+                "Centrist parties (D66, CDA, CU, NSC) moved left on both axes "
+                "while right-wing parties stayed put. Right-wing parties filed milder "
+                "motions, so centrists could vote along more often "
+                "without shifting ideologically to the right.\n\n"
+                "[Read the full analysis](../reports/overton_window/overton_window.qmd)\n\n"
+                "Try the Stemwijzer quiz to see which MP matches your positions."
+            )
+        st.markdown("---")
+        st.markdown(
+            "**Voting discipline analysis:** The Rice index measures how united parties vote "
+            "during roll-call votes. A score of 100% means all MPs of a party voted the "
+            "same way; 50% indicates an even split within the party. "
+            "High-discipline parties (>95%) like PVV and SGP vote as a bloc, indicating "
+            "strong party discipline and homogeneous membership. Lower discipline (<85%) "
+            "in parties like PvdA or SP may indicate internal factional struggles, conscience "
+            "votes on ethical issues, or a broad ideological course that leaves room for "
+            "dissenting opinions. Discipline also varies by topic: ethical issues "
+            "tend to show more internal division than economic topics."
+        )

analysis/tabs/components.py

@@ -0,0 +1,372 @@
+"""SVD Components tab for the parliamentary explorer."""
+
+from __future__ import annotations
+
+import datetime as _dt
+import logging
+import os
+from typing import Dict, List, Tuple
+
+import numpy as np
+
+from analysis import config
+import analysis.explorer_data as explorer_data
+from analysis.tabs._rendering import (
+    _render_party_axis_chart_1d,
+    _render_scree_plot,
+    _render_svd_time_trajectory,
+    _render_voting_results,
+    st,
+)
+
+try:
+    import duckdb
+except Exception:
+    duckdb = None  # type: ignore
+
+SVD_THEMES = config.SVD_THEMES
+KNOWN_MAJOR_PARTIES = config.KNOWN_MAJOR_PARTIES
+
+logger = logging.getLogger(__name__)
+
+
+def build_svd_components_tab(db_path: str) -> None:
+    """New tab: show top motions contributing to top SVD components.
+
+    Reads thoughts/explorer/top_svd_top_motions.json and displays a selector
+    for components 1..10 with theme labels/explanations and a detail pane per motion.
+
+    Components 1-2 use aligned PCA positions (consistent with compass).
+    Components 3-10 use raw SVD scores.
+    """
+    st.subheader("SVD Assen — politieke polarisatiethema's")
+    st.markdown(
+        "Elke SVD-as representeert een latente politieke dimensie afgeleid uit stempatronen "
+        "van alle Kamerleden. De top-10 moties per as zijn uniek (geen overlap) en illustreren "
+        "het spanningsveld dat de as beschrijft."
+    )
+
+    scree_importances = explorer_data.load_scree_data(db_path)
+    if scree_importances:
+        st.markdown(
+            "**Scree-plot** — het relatieve gewicht van elke SVD-as. "
+            "De eerste assen verklaren het meeste van de stemverschillen in de Kamer; "
+            "latere assen (7+) zijn fragiel en mogelijk niet boven ruisniveau."
+        )
+        _render_scree_plot(scree_importances)
+
+    json_path = os.path.join("thoughts", "explorer", "top_svd_top_motions.json")
+    if not os.path.exists(json_path):
+        st.warning(
+            f"Top-SVD data not found at {json_path}. Run the importance job to generate it."
+        )
+        return
+
+    try:
+        import json
+
+        with open(json_path, "r", encoding="utf-8") as fh:
+            j = json.load(fh)
+    except Exception as e:
+        st.error(f"Failed to load SVD importance JSON: {e}")
+        return
+
+    window = j.get("window")
+    rows = j.get("rows", [])
+    if not rows:
+        st.info("Geen top-moties in dataset")
+        return
+
+    st.caption(f"Top SVD-bijdragers berekend voor venster: **{window}**")
+
+    comp_map: dict[int, list] = {}
+    for r in rows:
+        comp = int(r.get("component", 0))
+        bucket = comp_map.setdefault(comp, [])
+        existing_ids = {m.get("motion_id") for m in bucket}
+        if r.get("motion_id") not in existing_ids:
+            bucket.append(r)
+
+    comp_options = sorted(comp_map.keys())
+
+    def _comp_label(c: int) -> str:
+        theme = SVD_THEMES.get(c, {})
+        lbl = theme.get("label", "")
+        return f"As {c} — {lbl}" if lbl else f"As {c}"
+
+    comp_display = [_comp_label(c) for c in comp_options]
+
+    party_scores_default = explorer_data.load_party_axis_scores(db_path)
+    party_mp_vectors = explorer_data.load_party_mp_vectors(db_path)
+    bootstrap_data = None
+    if party_mp_vectors:
+        try:
+            from analysis.political_axis import compute_party_bootstrap_cis
+
+            bootstrap_data = compute_party_bootstrap_cis(party_mp_vectors)
+        except Exception:
+            pass
+
+    col1, col2 = st.columns([2, 1])
+
+    view_mode = "Enkel venster"
+    selected_parties_for_trajectory: list = []
+
+    with col2:
+        comp_sel_idx = st.selectbox(
+            "Selecteer SVD-as",
+            options=list(range(len(comp_options))),
+            format_func=lambda i: comp_display[i],
+            index=0,
+        )
+        comp_sel = comp_options[comp_sel_idx]
+
+        min_mps = st.number_input(
+            "Min. Kamerleden per partij",
+            min_value=1,
+            max_value=20,
+            value=1,
+            step=1,
+            help="Partijen met minder dan dit aantal Kamerleden worden niet weergegeven.",
+        )
+
+        view_mode = st.radio(
+            "Weergave",
+            options=["Enkel venster", "Tijdtraject"],
+            index=0,
+            help="Enkel venster: toont posities voor één tijdsvenster. Tijdtraject: toont hoe partijen over tijd bewegen op deze as.",
+        )
+
+        selected_parties_for_trajectory = []
+        if view_mode == "Tijdtraject":
+            all_parties = (
+                sorted(party_scores_default.keys()) if party_scores_default else []
+            )
+            default_parties = [p for p in KNOWN_MAJOR_PARTIES if p in all_parties][:8]
+            selected_parties_for_trajectory = st.multiselect(
+                "Partijen om te tonen",
+                options=all_parties,
+                default=default_parties,
+                help="Selecteer de partijen die je wilt zien in het tijdtraject.",
+            )
+
+    theme = SVD_THEMES.get(comp_sel, {})
+    if theme:
+        st.info(f"**{theme['label']}** — {theme['explanation']}")
+
+    motions = comp_map.get(comp_sel, [])
+
+    _current_year = str(_dt.date.today().year)
+    available_windows = explorer_data.get_uniform_dim_windows(db_path)
+    year_windows = sorted(
+        w for w in available_windows if w != "current_parliament" and w != _current_year
+    )
+    has_current = "current_parliament" in available_windows
+    svd_windows = year_windows + (["current_parliament"] if has_current else [])
+
+    def _svd_window_label(w: str) -> str:
+        if w == "current_parliament":
+            return "Huidig parlement"
+        return w
+
+    with col1:
+        svd_window = st.selectbox(
+            "Jaar",
+            options=svd_windows,
+            index=len(svd_windows) - 1,
+            format_func=_svd_window_label,
+            key=f"svd_window_{comp_sel}",
+        )
+
+    if svd_window == "current_parliament":
+        party_scores = party_scores_default
+    else:
+        party_scores = explorer_data.load_party_axis_scores_for_window(db_path, svd_window)
+
+    party_mp_counts = (
+        {p: len(v) for p, v in party_mp_vectors.items()} if party_mp_vectors else {}
+    )
+
+    def _get_aligned_party_coords(window: str) -> Dict[str, Tuple[float, float]]:
+        """Get party (x, y) coordinates from aligned PCA positions for a window."""
+        positions_by_window, _ = explorer_data.load_positions(db_path, "annual")
+        window_pos = positions_by_window.get(window, {})
+        if not window_pos:
+            return {}
+
+        _party_map = explorer_data.load_party_map(db_path)
+
+        party_coords: Dict[str, List[Tuple[float, float]]] = {}
+        for mp_name, (x, y) in window_pos.items():
+            party = _party_map.get(
+                mp_name, _party_map.get(mp_name.split("(")[0].strip(), None)
+            )
+            if party:
+                party_coords.setdefault(party, []).append((x, y))
+
+        return {
+            party: (
+                float(np.mean([c[0] for c in coords])),
+                float(np.mean([c[1] for c in coords])),
+            )
+            for party, coords in party_coords.items()
+            if coords
+        }
+
+    active_mps = (
+        explorer_data.load_active_mps(db_path)
+        if svd_window == "current_parliament"
+        else None
+    )
+    aligned_all_scores = explorer_data.get_aligned_party_scores(
+        db_path, svd_window, active_mps
+    )
+
+    party_1d_coords: dict = {}
+    for party, all_scores in aligned_all_scores.items():
+        idx = comp_sel - 1
+        if idx < len(all_scores):
+            party_1d_coords[party] = (float(all_scores[idx]),)
+
+    computed_flips: Dict[int, bool] = {}
+    try:
+        from analysis.config import CANONICAL_LEFT, CANONICAL_RIGHT
+
+        for comp_idx in range(10):
+            right_scores = []
+            left_scores = []
+            for party, scores in aligned_all_scores.items():
+                if party in CANONICAL_RIGHT:
+                    right_scores.append(scores[comp_idx])
+                elif party in CANONICAL_LEFT:
+                    left_scores.append(scores[comp_idx])
+
+            if right_scores and left_scores:
+                right_avg = np.mean(right_scores)
+                left_avg = np.mean(left_scores)
+                computed_flips[comp_idx + 1] = right_avg < left_avg
+            else:
+                computed_flips[comp_idx + 1] = False
+    except Exception:
+        pass
+
+    theme_with_flip = {
+        **theme,
+        "flip": computed_flips.get(comp_sel, theme.get("flip", False)),
+    }
+
+    if min_mps > 1 and party_mp_counts:
+        valid_parties = {p for p, count in party_mp_counts.items() if count >= min_mps}
+        party_1d_coords = {
+            p: coords for p, coords in party_1d_coords.items() if p in valid_parties
+        }
+
+    if view_mode == "Tijdtraject" and selected_parties_for_trajectory:
+        available_windows = explorer_data.get_uniform_dim_windows(db_path)
+        year_windows = sorted(
+            w
+            for w in available_windows
+            if w != "current_parliament" and w != _current_year
+        )
+        has_current = "current_parliament" in available_windows
+        all_windows = year_windows + (["current_parliament"] if has_current else [])
+
+        party_scores_by_window = explorer_data._get_aligned_trajectory_scores(
+            db_path, all_windows
+        )
+
+        _render_svd_time_trajectory(
+            party_scores_by_window,
+            comp_sel,
+            theme_with_flip,
+            selected_parties_for_trajectory,
+        )
+    else:
+        _render_party_axis_chart_1d(party_1d_coords, comp_sel, theme_with_flip)
+
+    motion_ids = [m.get("motion_id") for m in motions if m.get("motion_id") is not None]
+    motion_details: Dict[int, tuple] = {}
+    if motion_ids:
+        ids_int: List[int] = []
+        for mid in motion_ids:
+            try:
+                ids_int.append(int(mid))
+            except Exception:
+                logger.warning("Skipping invalid motion id in SVD batch fetch: %r", mid)
+
+        if ids_int and duckdb is not None:
+            con = None
+            try:
+                placeholders = ", ".join("?" for _ in ids_int)
+                con = duckdb.connect(database=db_path, read_only=True)
+                db_rows = con.execute(
+                    f"SELECT id, title, date, policy_area, url, body_text, voting_results "
+                    f"FROM motions WHERE id IN ({placeholders})",
+                    ids_int,
+                ).fetchall()
+                motion_details = {r[0]: r for r in db_rows}
+            except Exception:
+                logger.exception("Failed to batch-fetch motion details")
+            finally:
+                if con:
+                    con.close()
+
+    pos_motions = [m for m in motions if float(m.get("score", 0.0)) >= 0]
+    neg_motions = [m for m in motions if float(m.get("score", 0.0)) < 0]
+
+    flip = theme_with_flip.get("flip", False) if theme_with_flip else False
+    pos_pole = theme_with_flip.get("positive_pole", "") if theme_with_flip else ""
+    neg_pole = theme_with_flip.get("negative_pole", "") if theme_with_flip else ""
+
+    if flip:
+        left_pole, right_pole = pos_pole, neg_pole
+        left_motions, right_motions = pos_motions, neg_motions
+    else:
+        left_pole, right_pole = neg_pole, pos_pole
+        left_motions, right_motions = neg_motions, pos_motions
+
+    lcol, rcol = st.columns(2)
+
+    with lcol:
+        st.markdown(f"**← {left_pole}**")
+        for m in left_motions:
+            mid = m.get("motion_id")
+            raw_title = m.get("title") or f"Motie #{mid}"
+            with st.expander(raw_title):
+                row = motion_details.get(int(mid)) if mid is not None else None
+                if row:
+                    try:
+                        date_str = str(row[2])[:10]
+                    except Exception:
+                        date_str = "?"
+                    st.caption(f"{date_str}  |  {row[3] or '—'}")
+                    if row[4] and str(row[4]).startswith("http"):
+                        st.markdown(f"[Bekijk op Tweede Kamer]({row[4]})")
+                    if row[5]:
+                        with st.expander("Toon volledige tekst"):
+                            st.write(row[5])
+                    _render_voting_results(row[6])
+                else:
+                    st.caption("_Geen metadata beschikbaar_")
+
+    with rcol:
+        st.markdown(f"**{right_pole} →**")
+        for m in right_motions:
+            mid = m.get("motion_id")
+            raw_title = m.get("title") or f"Motie #{mid}"
+            with st.expander(raw_title):
+                row = motion_details.get(int(mid)) if mid is not None else None
+                if row:
+                    try:
+                        date_str = str(row[2])[:10]
+                    except Exception:
+                        date_str = "?"
+                    st.caption(f"{date_str}  |  {row[3] or '—'}")
+                    if row[4] and str(row[4]).startswith("http"):
+                        st.markdown(f"[Bekijk op Tweede Kamer]({row[4]})")
+                    if row[5]:
+                        with st.expander("Toon volledige tekst"):
+                            st.write(row[5])
+                    _render_voting_results(row[6])
+                else:
+                    st.caption("_Geen metadata beschikbaar_")

analysis/tabs/overton.py

@@ -0,0 +1,213 @@
+"""Overton Window tab for the parliamentary explorer."""
+
+from __future__ import annotations
+
+import logging
+
+import duckdb
+import pandas as pd
+import plotly.graph_objects as go
+
+from analysis.tabs._rendering import st
+
+logger = logging.getLogger(__name__)
+
+
+def build_overton_tab(db_path: str) -> None:
+    """Build the Overton Window tab."""
+    st.subheader("Overton Window Analysis")
+    st.markdown(
+        "After 2024, centrist support for right-wing motions increased from 25% to 51%, "
+        "while support for left-wing motions remained flat. "
+        "Right-wing parties filed milder motions, so centrists could vote along "
+        "without shifting ideologically."
+    )
+
+    try:
+        con = duckdb.connect(db_path, read_only=True)
+    except Exception:
+        st.warning("Cannot connect to the database.")
+        return
+
+    try:
+        tables = con.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='right_wing_motions'"
+        ).fetchall()
+        if not tables:
+            st.info(
+                "The right_wing_motions table is not yet available. "
+                "Run the pipeline to generate it."
+            )
+            return
+    except Exception:
+        st.info("The right_wing_motions table is not available.")
+        return
+
+    try:
+        _render_centrist_support_chart(con)
+        _render_summary_stats(con)
+        _render_migration_gateway(con)
+        _render_motion_browser(con)
+        _render_explore_further()
+    except Exception as e:
+        st.error(f"Error loading Overton data: {e}")
+        logger.exception("Overton tab error")
+    finally:
+        con.close()
+
+
+def _render_centrist_support_chart(con: duckdb.DuckDBPyConnection) -> None:
+    df = con.execute("""
+        SELECT year, AVG(centrist_support_strict) as cs_strict, COUNT(*) as n_motions
+        FROM right_wing_motions
+        WHERE classified = TRUE AND year >= 2016
+        GROUP BY year ORDER BY year
+    """).fetchdf()
+
+    if df.empty:
+        st.info("No centrist support data available.")
+        return
+
+    fig = go.Figure()
+
+    fig.add_trace(go.Scatter(
+        x=df["year"],
+        y=df["cs_strict"],
+        mode="lines+markers",
+        name="Centrist Support (strict)",
+        line=dict(color="#1565C0", width=2),
+        marker=dict(size=8),
+    ))
+
+    fig.add_trace(go.Bar(
+        x=df["year"],
+        y=df["n_motions"],
+        name="Motion count",
+        yaxis="y2",
+        marker_color="#90CAF9",
+        opacity=0.5,
+    ))
+
+    fig.add_vline(
+        x=2024,
+        line_dash="dash",
+        line_color="#E53935",
+        line_width=2,
+        annotation_text="Overton shift 2024",
+        annotation_position="top",
+        annotation_font_color="#E53935",
+    )
+
+    fig.update_layout(
+        title="Centrist Support for Right-Wing Motions",
+        xaxis=dict(title="Year", dtick=1),
+        yaxis=dict(title="Centrist Support", range=[0, 1]),
+        yaxis2=dict(title="Motion count", overlaying="y", side="right"),
+        height=400,
+        legend=dict(orientation="h", y=1.1),
+        hovermode="x unified",
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+
+def _render_summary_stats(con: duckdb.DuckDBPyConnection) -> None:
+    st.subheader("Summary")
+
+    result = con.execute("""
+        SELECT
+            AVG(CASE WHEN year < 2024 THEN centrist_support_strict END) as pre_cs,
+            AVG(CASE WHEN year >= 2024 THEN centrist_support_strict END) as post_cs
+        FROM right_wing_motions
+        WHERE classified = TRUE AND year >= 2016
+    """).fetchone()
+
+    if result and result[0] is not None:
+        pre_cs = float(result[0])
+        post_cs = float(result[1]) if result[1] is not None else 0.0
+        shift = post_cs - pre_cs
+    else:
+        pre_cs = 0.251
+        post_cs = 0.507
+        shift = 0.256
+
+    col1, col2, col3, col4 = st.columns(4)
+    col1.metric("Pre-2024 CS", f"{pre_cs:.3f}")
+    col2.metric("Post-2024 CS", f"{post_cs:.3f}")
+    col3.metric("Shift", f"{shift:+.3f}")
+    col4.metric("2D correlation r", "0.47")
+
+
+def _render_migration_gateway(con: duckdb.DuckDBPyConnection) -> None:
+    st.subheader("Migration: the gateway domain")
+    st.markdown(
+        "Migration showed the largest shift in centrist support. "
+        "Framing patterns first used here later appeared in other policy domains."
+    )
+
+    df = con.execute("""
+        SELECT
+            CASE WHEN year < 2024 THEN 'Pre-2024' ELSE 'Post-2024' END as period,
+            AVG(centrist_support_strict) as cs_strict,
+            COUNT(*) as n_motions
+        FROM right_wing_motions
+        WHERE classified = TRUE
+          AND year >= 2016
+          AND category IN ('asiel/vreemdelingen', 'asiel')
+        GROUP BY period
+        ORDER BY period
+    """).fetchdf()
+
+    if df.empty or len(df) < 2:
+        return
+
+    pre = df[df["period"] == "Pre-2024"].iloc[0]
+    post = df[df["period"] == "Post-2024"].iloc[0]
+
+    col1, col2, col3, col4 = st.columns(4)
+    col1.metric("Pre-2024 CS (migration)", f"{pre['cs_strict']:.3f}")
+    col2.metric("Post-2024 CS (migration)", f"{post['cs_strict']:.3f}")
+    col3.metric("Shift", f"{post['cs_strict'] - pre['cs_strict']:+.3f}")
+    col4.metric("Motions", f"{int(pre['n_motions'] + post['n_motions'])}")
+
+    st.caption(
+        "For comparison: non-migration motions went from 0.276 to 0.481 (+0.205). "
+        "Migration rose more than twice as fast (+0.216), while material impact "
+        "barely declined. CDA and ChristenUnie doubled their migration support "
+        "(18% to 40%, 10% to 30%)."
+    )
+
+
+def _render_motion_browser(con: duckdb.DuckDBPyConnection) -> None:
+    st.subheader("Right-Wing Motions Browser")
+
+    df = con.execute("""
+        SELECT r.year, r.title, m.body_text, r.centrist_support_strict, r.category
+        FROM right_wing_motions r
+        LEFT JOIN motions m ON r.motion_id = m.id
+        WHERE r.classified = TRUE
+        ORDER BY r.centrist_support_strict DESC
+        LIMIT 100
+    """).fetchdf()
+
+    if df.empty:
+        st.info("No right-wing motions found.")
+        return
+
+    df = df.rename(columns={
+        "year": "Year",
+        "title": "Title",
+        "body_text": "Motion text",
+        "centrist_support_strict": "Centrist Support",
+        "category": "Category",
+    })
+    st.dataframe(df, use_container_width=True, height=600)
+
+
+def _render_explore_further() -> None:
+    st.subheader("Explore further")
+    st.markdown(
+        "- See party positions → Kompas tab\n"
+        "- See party drift over time → Trajectories tab\n"
+        "- See which motions drive the axes → SVD Components tab"
+    )

analysis/tabs/quiz.py

@@ -0,0 +1,132 @@
+"""MP Quiz tab for the parliamentary explorer."""
+
+from __future__ import annotations
+
+import pandas as pd
+
+import analysis.explorer_data as explorer_data
+from analysis.tabs._rendering import st
+
+
+def build_mp_quiz_tab(db_path: str) -> None:
+    """Interactive quiz: narrow MPs by asking motion vote questions.
+
+    Minimal viable flow:
+    - seed with top-N controversial motions (SEED_MOTIONS)
+    - present one question at a time, store answers in st.session_state['mp_quiz_votes']
+    - after each answer call MotionDatabase.match_mps_for_votes to rank MPs
+    - if multiple candidates remain, call choose_discriminating_motions to pick next question
+    - stop when unique MP found or no discriminating motions remain
+    """
+    st.subheader("Welk tweede kamerlid ben jij?")
+    st.markdown(
+        "Beantwoord een paar eenvoudige ja/nee/onthoud vragen over moties om te zien welk Kamerlid het meest op jou lijkt."
+    )
+
+    SEED_MOTIONS = 8
+    MAX_QUESTIONS = 20
+
+    if "mp_quiz_votes" not in st.session_state:
+        st.session_state["mp_quiz_votes"] = {}
+    if "mp_quiz_asked" not in st.session_state:
+        st.session_state["mp_quiz_asked"] = []
+
+    from database import MotionDatabase as _MotionDatabase
+
+    db_inst = _MotionDatabase(db_path)
+
+    df = explorer_data.load_motions_df(db_path)
+    if df.empty:
+        st.warning("Geen moties beschikbaar om de quiz te starten.")
+        return
+
+    seed_ids = db_inst.get_motions_with_individual_votes(k=SEED_MOTIONS)
+    if not seed_ids:
+        st.warning("Geen individuele stemdata beschikbaar voor de quiz.")
+        return
+
+    def _next_motion_id():
+        for mid in seed_ids:
+            if str(mid) not in st.session_state["mp_quiz_votes"]:
+                return mid
+        try:
+            user_votes = {
+                int(k): v for k, v in st.session_state["mp_quiz_votes"].items()
+            }
+            ranked = db_inst.match_mps_for_votes(user_votes, limit=200)
+        except Exception:
+            ranked = []
+
+        candidates = [r["mp_name"] for r in ranked]
+        excluded = [int(k) for k in st.session_state["mp_quiz_votes"].keys()]
+        if not candidates:
+            return None
+        try:
+            next_ids = db_inst.choose_discriminating_motions(candidates, excluded, k=1)
+            return next_ids[0] if next_ids else None
+        except Exception:
+            return None
+
+    col1, col2 = st.columns([3, 1])
+    with col2:
+        st.caption(
+            f"Vragen beantwoord: {len(st.session_state['mp_quiz_votes'])}/{MAX_QUESTIONS}"
+        )
+        if st.button("Reset quiz"):
+            st.session_state["mp_quiz_votes"] = {}
+            st.session_state["mp_quiz_asked"] = []
+            st.rerun()
+
+    next_mid = _next_motion_id()
+    if next_mid is None:
+        st.info("Geen nieuwe vragen beschikbaar om kandidaten te scheiden.")
+    else:
+        motion_rows = df[df["id"] == next_mid]
+        if motion_rows.empty:
+            st.session_state["mp_quiz_votes"][str(next_mid)] = "Geen stem"
+            st.rerun()
+            return
+        motion_row = motion_rows.iloc[0]
+        st.markdown(f"### {motion_row.get('title') or f'Motie #{next_mid}'}")
+        if motion_row.get("layman_explanation"):
+            st.info(motion_row.get("layman_explanation"))
+
+        with st.form(key=f"mp_quiz_form_{next_mid}"):
+            choice = st.radio(
+                "Wat zou jij stemmen?",
+                options=["Voor", "Tegen", "Onthouden", "Geen stem"],
+                index=3,
+            )
+            submitted = st.form_submit_button("Beantwoord en verder")
+
+        if submitted:
+            st.session_state["mp_quiz_votes"][str(next_mid)] = choice
+            st.session_state["mp_quiz_asked"].append(next_mid)
+            st.rerun()
+
+    try:
+        user_votes = {int(k): v for k, v in st.session_state["mp_quiz_votes"].items()}
+        ranking = db_inst.match_mps_for_votes(user_votes, limit=50)
+    except Exception:
+        ranking = []
+
+    if ranking:
+        st.markdown("**Top kandidaten**")
+        rdf = pd.DataFrame(ranking)
+        st.dataframe(rdf.head(10), use_container_width=True)
+
+        top_pct = ranking[0]["agreement_pct"] if ranking else 0.0
+        top_matches = [r for r in ranking if r["agreement_pct"] == top_pct]
+        if len(top_matches) == 1 and top_matches[0]["overlap"] > 0:
+            st.success(
+                f"Unieke match gevonden: {top_matches[0]['mp_name']} ({top_matches[0]['party']})"
+            )
+        else:
+            if len(st.session_state["mp_quiz_asked"]) >= MAX_QUESTIONS:
+                st.warning(
+                    "Maximaal aantal vragen beantwoord. Je hebt meerdere vergelijkbare kandidaten."
+                )
+            else:
+                st.info("Nog geen unieke match — vraag meer om verder te verfijnen.")
+    else:
+        st.info("Nog geen antwoorden of geen overlapping met bestaande stemdata.")

analysis/tabs/search.py

@@ -0,0 +1,84 @@
+"""Search tab for the parliamentary explorer."""
+
+from __future__ import annotations
+
+import pandas as pd
+
+import analysis.explorer_data as explorer_data
+from analysis.tabs._rendering import _render_voting_results, st
+
+
+def build_search_tab(db_path: str, show_rejected: bool) -> None:
+    """Build the Motie Zoeken tab."""
+    st.subheader("Motie Zoeken")
+
+    df = explorer_data.load_motions_df(db_path)
+    if df.empty:
+        st.warning("Geen moties beschikbaar.")
+        return
+
+    if not show_rejected:
+        df = df[df["title"].fillna("").str.strip() != "Verworpen."]
+
+    col1, col2, col3 = st.columns([2, 1, 1])
+    with col1:
+        query = st.text_input(
+            "Zoek op titel", placeholder="bijv. stikstof, klimaat, wonen"
+        )
+    with col2:
+        years = sorted(df["year"].dropna().astype(int).unique().tolist())
+        if years:
+            year_range = st.select_slider(
+                "Jaar", options=years, value=(years[0], years[-1])
+            )
+        else:
+            year_range = (2019, 2024)
+    with col3:
+        min_controversy = st.slider(
+            "Min. controverse", min_value=0.0, max_value=1.0, value=0.0, step=0.05
+        )
+
+    working = df.copy()
+    working = working[
+        (working["year"] >= year_range[0]) & (working["year"] <= year_range[1])
+    ]
+    if min_controversy > 0:
+        working = working[working["controversy_score"] >= min_controversy]
+    if query:
+        q = query.lower()
+        mask = working["title"].fillna("").str.lower().str.contains(q, regex=False)
+        working = working[mask]
+
+    working = working.sort_values(by="controversy_score", ascending=False)
+    st.caption(f"{len(working)} resultaten (top 50 getoond)")
+
+    for _, row in working.head(50).iterrows():
+        title = row.get("title") or f"Motie #{row['id']}"
+        date_str = row["date"].strftime("%d %b %Y") if pd.notna(row["date"]) else "?"
+        controversy = row.get("controversy_score") or 0
+        with st.expander(f"**{title}** — {date_str} — {controversy:.2f}"):
+            cols = st.columns(3)
+            cols[0].metric("Controverse", f"{controversy:.2f}")
+            cols[1].metric("Marge", f"{row.get('winning_margin', 0):.2f}")
+            cols[2].metric("Jaar", int(row["year"]) if pd.notna(row["year"]) else "?")
+
+            _render_voting_results(row.get("voting_results"))
+
+            url = row.get("url")
+            if url and str(url).startswith("http"):
+                st.markdown(f"[Bekijk op Tweede Kamer]({url})")
+
+            sim = explorer_data.query_similar(db_path, int(row["id"]), top_k=5)
+            if not sim.empty:
+                st.markdown("**Vergelijkbare moties:**")
+                for _, s in sim.iterrows():
+                    s_date = (
+                        pd.to_datetime(s["date"]).strftime("%Y")
+                        if pd.notna(s.get("date"))
+                        else ""
+                    )
+                    st.markdown(
+                        f"- {s.get('title', 'Onbekend')} *(score: {s['score']:.3f}, {s_date})*"
+                    )
+            else:
+                st.caption("_Nog geen vergelijkbare moties beschikbaar_")

analysis/tabs/trajectories.py

@@ -0,0 +1,675 @@
+"""Trajectories tab for the parliamentary explorer."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import traceback
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+
+from analysis import config
+import analysis.explorer_data as explorer_data
+from analysis import trajectory
+from analysis.tabs._rendering import (
+    PARTY_COLOURS,
+    _add_y_direction_annotations,
+    go,
+    st,
+)
+from explorer_helpers import compute_party_centroids, inspect_positions_for_issues
+
+KNOWN_MAJOR_PARTIES = config.KNOWN_MAJOR_PARTIES
+
+logger = logging.getLogger(__name__)
+
+_last_trajectories_diagnostics: dict = {}
+_last_diagnostics = _last_trajectories_diagnostics
+
+
+def get_debug_trajectories_enabled() -> bool:
+    """Return True when EXPLORER_DEBUG_TRAJECTORIES env var indicates debug mode."""
+    v = os.getenv("EXPLORER_DEBUG_TRAJECTORIES")
+    return str(v) in ("1", "true", "True")
+
+
+def select_trajectory_plot_data(
+    positions_by_window: Dict[str, Dict[str, Tuple[float, float]]],
+    party_map: Dict[str, str],
+    windows: List[str],
+    selected_parties: List[str],
+    smooth_alpha: float = 0.35,
+    mp_fallback_count: Optional[int] = None,
+) -> Tuple[go.Figure, int, Optional[str]]:
+    """Return (fig, trace_count, banner_text).
+
+    Helper used by build_trajectories_tab. Does not call Streamlit.
+    """
+    if mp_fallback_count is None:
+        try:
+            mp_fallback_count = int(os.getenv("EXPLORER_MP_FALLBACK_COUNT", "20"))
+        except Exception:
+            mp_fallback_count = 20
+
+    party_centroids, meta = compute_party_centroids(
+        positions_by_window, party_map, windows
+    )
+
+    try:
+        inspector_summary = inspect_positions_for_issues(positions_by_window, party_map)
+    except Exception:
+        tb = traceback.format_exc()
+        inspector_summary = {}
+        try:
+            select_trajectory_plot_data._last_diagnostics = {
+                "stage": "inspector_exception",
+                "exception": tb,
+            }
+        except Exception:
+            pass
+        try:
+            _last_trajectories_diagnostics.update(
+                {"stage": "inspector_exception", "exception": tb}
+            )
+        except Exception:
+            pass
+    logger.debug("select_trajectory_plot_data inspector summary: %s", inspector_summary)
+
+    plottable_parties = []
+    for p, vals in party_centroids.items():
+        has_valid = any(not (np.isnan(x) and np.isnan(y)) for x, y in vals)
+        if has_valid:
+            plottable_parties.append(p)
+
+    logging.getLogger(__name__).debug(
+        "[TRAJ DEBUG] plottable_parties: %d parties, sample=%s",
+        len(plottable_parties),
+        (plottable_parties[:5] if plottable_parties else "empty"),
+    )
+    logging.getLogger(__name__).debug(
+        "[TRAJ DEBUG] party_centroids keys: %s",
+        list(party_centroids.keys())[:10],
+    )
+    if party_centroids:
+        sample_party = list(party_centroids.keys())[0]
+        sample_vals = party_centroids[sample_party]
+        logging.getLogger(__name__).debug(
+            "[TRAJ DEBUG] Sample party '%s' centroids: %s...",
+            sample_party,
+            sample_vals[:3],
+        )
+
+    fig = go.Figure()
+    trace_count = 0
+    banner_text: Optional[str] = None
+
+    def _ema_smooth(values: List[float], alpha: float) -> List[float]:
+        if not values or alpha >= 1.0:
+            return values
+        smoothed: List[float] = []
+        prev = None
+        for v in values:
+            if v is None or (isinstance(v, float) and np.isnan(v)):
+                smoothed.append(float(np.nan))
+                continue
+            v = float(v)
+            if prev is None:
+                prev = v
+            else:
+                prev = alpha * v + (1 - alpha) * prev
+            smoothed.append(float(prev))
+        return smoothed
+
+    if not plottable_parties:
+        mp_positions: Dict[str, Dict[str, Tuple[float, float]]] = {}
+        for wid in windows:
+            pos = positions_by_window.get(wid, {})
+            for mp_name, xy in pos.items():
+                try:
+                    x, y = float(xy[0]), float(xy[1])
+                except Exception:
+                    continue
+                mp_positions.setdefault(mp_name, {})[wid] = (x, y)
+
+        mp_activity = sorted(
+            [(mp, len(wdict)) for mp, wdict in mp_positions.items()],
+            key=lambda t: t[1],
+            reverse=True,
+        )
+        top_mps = [mp for mp, _ in mp_activity[:mp_fallback_count]]
+
+        for mp in top_mps:
+            wids_sorted = sorted(mp_positions.get(mp, {}).keys())
+            if not wids_sorted:
+                continue
+            xs_raw = [mp_positions[mp][w][0] for w in wids_sorted]
+            ys_raw = [mp_positions[mp][w][1] for w in wids_sorted]
+            xs = _ema_smooth(xs_raw, smooth_alpha)
+            ys = _ema_smooth(ys_raw, smooth_alpha)
+            custom_raw = [
+                (
+                    float(rx) if rx is not None else float(np.nan),
+                    float(ry) if ry is not None else float(np.nan),
+                )
+                for rx, ry in zip(xs_raw, ys_raw)
+            ]
+            fig.add_trace(
+                go.Scatter(
+                    x=xs,
+                    y=ys,
+                    mode="lines+markers",
+                    name=mp,
+                    text=wids_sorted,
+                    customdata=custom_raw,
+                    line=dict(color="#888888", shape="spline", smoothing=1.3),
+                    marker=dict(color="#888888", size=6),
+                )
+            )
+            trace_count += 1
+
+        banner_text = "Partijcentroiden niet beschikbaar — tonen individuele MP-trajecten als fallback."
+        logging.getLogger(__name__).debug(
+            "[TRAJ DEBUG] Fallback to MP trajectories: trace_count=%d, top_mps=%d",
+            trace_count,
+            len(top_mps),
+        )
+        return fig, trace_count, banner_text
+
+    to_plot = [p for p in selected_parties if p in plottable_parties]
+    if not to_plot:
+        to_plot = plottable_parties
+
+    for party in to_plot:
+        vals = party_centroids.get(party, [])
+        if not vals:
+            continue
+        xs_raw = [v[0] for v in vals]
+        ys_raw = [v[1] for v in vals]
+        xs = _ema_smooth(xs_raw, smooth_alpha)
+        ys = _ema_smooth(ys_raw, smooth_alpha)
+        custom_raw = [
+            (
+                float(x) if (x is not None and not np.isnan(x)) else float(np.nan),
+                float(y) if (y is not None and not np.isnan(y)) else float(np.nan),
+            )
+            for x, y in zip(xs_raw, ys_raw)
+        ]
+        colour = PARTY_COLOURS.get(party, "#9E9E9E")
+        fig.add_trace(
+            go.Scatter(
+                x=xs,
+                y=ys,
+                mode="lines+markers",
+                name=party,
+                text=windows,
+                customdata=custom_raw,
+                line=dict(color=colour, shape="spline", smoothing=1.3),
+                marker=dict(color=colour, size=8),
+            )
+        )
+        trace_count += 1
+
+    logging.getLogger(__name__).debug(
+        "[TRAJ DEBUG] Final trace_count=%d, plottable_parties=%d, to_plot=%s",
+        trace_count,
+        len(plottable_parties),
+        (len(to_plot) if "to_plot" in dir() else "N/A"),
+    )
+    return fig, trace_count, None
+
+
+def build_trajectories_tab(db_path: str, window_size: str) -> None:
+    """Build the Partij Trajectories tab."""
+    logging.getLogger(__name__).debug(
+        "[TRAJ DEBUG] build_trajectories_tab called — db_path=%s, window_size=%s",
+        db_path,
+        window_size,
+    )
+    st.subheader("Partij Trajectories")
+    st.markdown("Hoe bewegen partijen over de tijdsvensters heen?")
+
+    positions_by_window, axis_def = explorer_data.load_positions(db_path, window_size)
+    logging.getLogger(__name__).debug(
+        "[TRAJ DEBUG] load_positions → %d windows, total MPs=%d",
+        len(positions_by_window),
+        sum(len(v) for v in positions_by_window.values()),
+    )
+    if axis_def is None:
+        axis_def = {}
+    if not positions_by_window:
+        try:
+            _last_trajectories_diagnostics.update(
+                {
+                    "stage": "load_positions_empty",
+                    "positions_by_window_len": len(positions_by_window),
+                }
+            )
+        except Exception:
+            pass
+        try:
+            st.warning("Geen positiedata beschikbaar.")
+        except Exception:
+            pass
+        try:
+            if get_debug_trajectories_enabled():
+                try:
+                    st.text_area(
+                        "Trajectories diagnostics",
+                        json.dumps(_last_trajectories_diagnostics, default=str),
+                        height=160,
+                    )
+                except Exception:
+                    pass
+        except Exception:
+            pass
+        return
+
+    party_map = explorer_data.load_party_map(db_path)
+    logging.getLogger(__name__).debug(
+        "[TRAJ DEBUG] load_party_map → %d entries, sample=%s",
+        len(party_map),
+        list(party_map.items())[:3],
+    )
+
+    def normalize_mp_name(name):
+        """Normalize MP name for better matching between data sources."""
+        if not name:
+            return ""
+        name = name.strip()
+        if "," in name and ", " not in name:
+            name = name.replace(",", ", ")
+        return name
+
+    party_map = {normalize_mp_name(k): v for k, v in party_map.items()}
+
+    normalized_positions = {}
+    for window, positions in positions_by_window.items():
+        normalized_positions[window] = {
+            normalize_mp_name(k): v for k, v in positions.items()
+        }
+    positions_by_window = normalized_positions
+
+    all_mp_names = set()
+    for positions in positions_by_window.values():
+        all_mp_names.update(positions.keys())
+
+    matched_names = sum(1 for mp in all_mp_names if mp in party_map)
+    if all_mp_names:
+        logger.info(
+            f"MP name matching: {matched_names}/{len(all_mp_names)} matched ({100 * matched_names / len(all_mp_names):.1f}%)"
+        )
+    else:
+        logger.info("MP name matching: no MPs found in positions data")
+
+    if matched_names == 0 and len(all_mp_names) > 0:
+        logger.warning("No MP names matched between positions and party_map!")
+        logger.warning(f"Sample positions names: {list(all_mp_names)[:5]}")
+        logger.warning(f"Sample party_map names: {list(party_map.keys())[:5]}")
+
+    windows = sorted(positions_by_window.keys())
+
+    centroids: Dict[str, Dict[str, Tuple[float, float]]] = {}
+    all_parties: set = set()
+
+    def _strip_paren(name: str) -> str:
+        return re.sub(r"\s*\([^)]*\)", "", name).strip()
+
+    for wid in windows:
+        pos = positions_by_window.get(wid, {})
+        per_party: Dict[str, List[Tuple[float, float]]] = {}
+        for mp_name, (x, y) in pos.items():
+            party = party_map.get(mp_name) or party_map.get(
+                _strip_paren(mp_name), "Unknown"
+            )
+            if party == "Unknown":
+                continue
+            per_party.setdefault(party, []).append((x, y))
+        for party, coords in per_party.items():
+            all_parties.add(party)
+            xs = [c[0] for c in coords]
+            ys = [c[1] for c in coords]
+            centroids.setdefault(party, {})[wid] = (
+                float(np.mean(xs)),
+                float(np.mean(ys)),
+            )
+
+    all_parties = sorted(
+        set(party_map.get(mp) for MPs in positions_by_window.values() for mp in MPs)
+        - {None, "Unknown"}
+    )
+    logging.getLogger(__name__).debug(
+        "[TRAJ DEBUG] all_parties (raw from party_map) → %d parties: %s",
+        len(all_parties),
+        all_parties[:10],
+    )
+    all_parties_sorted = sorted(all_parties)
+
+    if not all_parties_sorted:
+        st.info(
+            "Geen partijen beschikbaar om trajecten te tekenen. Controleer of de party mapping is geladen (mp_metadata) en of de minimum Kamerleden-instelling te hoog staat."
+        )
+        try:
+            st.caption(f"Bekende partijen in party_map: {len(party_map)}")
+        except Exception:
+            pass
+
+    default_parties = [p for p in ["CDA", "D66", "VVD"] if p in all_parties]
+    if not default_parties:
+        default_parties = [p for p in KNOWN_MAJOR_PARTIES if p in all_parties]
+    if not default_parties:
+        default_parties = all_parties_sorted[:6]
+
+    selected_parties = st.multiselect(
+        "Selecteer partijen",
+        options=all_parties_sorted,
+        default=default_parties,
+    )
+
+    def _ema_smooth(values: List[float], alpha: float) -> List[float]:
+        if not values or alpha >= 1.0:
+            return values
+        smoothed = [values[0]]
+        for v in values[1:]:
+            smoothed.append(alpha * v + (1 - alpha) * smoothed[-1])
+        return smoothed
+
+    smooth_alpha = 0.35
+
+    if not centroids:
+        st.info(
+            "Partijcentroiden niet beschikbaar — tonen individuele MP-trajecten als fallback."
+        )
+
+        mp_positions: Dict[str, Dict[str, Tuple[float, float]]] = {}
+        for wid in windows:
+            pos = positions_by_window.get(wid, {})
+            for mp_name, xy in pos.items():
+                try:
+                    x, y = float(xy[0]), float(xy[1])
+                except Exception:
+                    continue
+                mp_positions.setdefault(mp_name, {})[wid] = (x, y)
+
+        mp_positions = {
+            mp: pos
+            for mp, pos in mp_positions.items()
+            if len(pos) >= 2
+            and not all(np.isnan(x) and np.isnan(y) for x, y in pos.values())
+        }
+
+        if not mp_positions:
+            st.warning("Geen positiedata beschikbaar voor trajectplotten.")
+            _last_trajectories_diagnostics.update(
+                {
+                    "stage": "no_mp_positions",
+                    "mp_positions_count": 0,
+                }
+            )
+            try:
+                if get_debug_trajectories_enabled():
+                    try:
+                        st.text_area(
+                            "Trajectories diagnostics",
+                            json.dumps(_last_trajectories_diagnostics, default=str),
+                            height=160,
+                        )
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+            return
+
+        st.session_state["_trajectory_mp_positions"] = mp_positions
+
+        mp_list = sorted(mp_positions.keys())
+        default_mps = mp_list[:6]
+        selected_mps = st.multiselect(
+            "Selecteer Kamerleden (fallback)", options=mp_list, default=default_mps
+        )
+
+        fig = go.Figure()
+        trace_count = 0
+        for mp in selected_mps:
+            wids_sorted = sorted(mp_positions[mp].keys())
+            xs_raw = [mp_positions[mp][w][0] for w in wids_sorted]
+            ys_raw = [mp_positions[mp][w][1] for w in wids_sorted]
+            xs = _ema_smooth(xs_raw, smooth_alpha)
+            ys = _ema_smooth(ys_raw, smooth_alpha)
+            custom_raw = [(float(rx), float(ry)) for rx, ry in zip(xs_raw, ys_raw)]
+            fig.add_trace(
+                go.Scatter(
+                    x=xs,
+                    y=ys,
+                    mode="lines+markers",
+                    name=mp,
+                    text=wids_sorted,
+                    customdata=custom_raw,
+                    line=dict(color="#888888", shape="spline", smoothing=1.3),
+                    marker=dict(color="#888888", size=6),
+                    hovertemplate=(
+                        f"<b>{mp}</b><br>"
+                        "venster: %{text}<br>"
+                        "x (smoothed): %{x:.3f}<br>"
+                        "x (raw): %{customdata[0]:.3f}<br>"
+                        "y (smoothed): %{y:.3f}<br>"
+                        "y (raw): %{customdata[1]:.3f}<extra></extra>"
+                    ),
+                )
+            )
+            trace_count += 1
+
+        _add_y_direction_annotations(fig)
+        if trace_count == 0:
+            st.info(
+                "Geen trajecten getekend: geen geselecteerde Kamerleden met voldoende data."
+            )
+        else:
+            st.plotly_chart(fig, use_container_width=True)
+        return
+
+    if os.getenv("EXPLORER_FORCE_SHOW_TRAJECTORIES") in ("1", "true", "True"):
+        mp_positions: Dict[str, Dict[str, Tuple[float, float]]] = {}
+        for wid in windows:
+            pos = positions_by_window.get(wid, {})
+            for mp_name, (x, y) in pos.items():
+                mp_positions.setdefault(mp_name, {})[wid] = (float(x), float(y))
+
+        mp_list = sorted(mp_positions.keys())
+        if not mp_list:
+            st.info("Geen MP-positiegegevens beschikbaar om te tonen.")
+            return
+
+        sample_mps = mp_list[:6]
+        fig = go.Figure()
+        for mp in sample_mps:
+            wids_sorted = sorted(mp_positions[mp].keys())
+            xs_raw = [mp_positions[mp][w][0] for w in wids_sorted]
+            ys_raw = [mp_positions[mp][w][1] for w in wids_sorted]
+            xs = _ema_smooth(xs_raw, 0.35)
+            ys = _ema_smooth(ys_raw, 0.35)
+            custom_raw = [(float(rx), float(ry)) for rx, ry in zip(xs_raw, ys_raw)]
+            fig.add_trace(
+                go.Scatter(
+                    x=xs,
+                    y=ys,
+                    mode="lines+markers",
+                    name=mp,
+                    text=wids_sorted,
+                    customdata=custom_raw,
+                    line=dict(color="#444444", shape="spline", smoothing=1.3),
+                    marker=dict(color="#444444", size=6),
+                    hovertemplate=(
+                        f"<b>{mp}</b><br>"
+                        "venster: %{text}<br>"
+                        "x (smoothed): %{x:.3f}<br>"
+                        "x (raw): %{customdata[0]:.3f}<br>"
+                        "y (smoothed): %{y:.3f}<br>"
+                        "y (raw): %{customdata[1]:.3f}<extra></extra>"
+                    ),
+                )
+            )
+        _add_y_direction_annotations(fig)
+        st.plotly_chart(fig, use_container_width=True)
+        return
+
+    smooth_alpha = 0.35
+
+    def _spline_smooth(values: List[float]) -> List[float]:
+        n = len(values)
+        if n <= 2:
+            return values
+        deg = min(3, n - 1)
+        try:
+            idx = np.arange(n, dtype=float)
+            coeffs = np.polyfit(idx, np.array(values, dtype=float), deg=deg)
+            smooth = np.polyval(coeffs, idx)
+            return [float(v) for v in smooth]
+        except Exception:
+            return values
+
+    fig = go.Figure()
+    trace_count = 0
+    helper_succeeded = False
+    try:
+        fig2, trace_count2, banner_text = select_trajectory_plot_data(
+            positions_by_window, party_map, windows, selected_parties, smooth_alpha
+        )
+        if fig2 is not None:
+            fig = fig2
+            trace_count = trace_count2
+            helper_succeeded = True
+            if banner_text:
+                try:
+                    st.caption(banner_text)
+                except Exception:
+                    pass
+                try:
+                    _last_trajectories_diagnostics.update({"banner_text": banner_text})
+                except Exception:
+                    pass
+    except Exception as e:
+        tb = traceback.format_exc()
+        try:
+            select_trajectory_plot_data._last_diagnostics = {"exception": tb}
+        except Exception:
+            pass
+        try:
+            _last_trajectories_diagnostics.update(
+                {"stage": "select_helper_exception", "exception": tb}
+            )
+        except Exception:
+            pass
+        logger.exception("select_trajectory_plot_data failed")
+        debug_enabled = get_debug_trajectories_enabled()
+        if debug_enabled:
+            try:
+                st.text_area("select_trajectory_plot_data traceback", tb, height=240)
+            except Exception:
+                pass
+    logging.getLogger(__name__).debug(
+        "[TRAJ DEBUG] helper_succeeded=%s", helper_succeeded
+    )
+    if not helper_succeeded:
+        for party in selected_parties:
+            if party not in centroids:
+                continue
+            wids_sorted = sorted(centroids[party].keys())
+            xs_raw = [centroids[party][w][0] for w in wids_sorted]
+            ys_raw = [centroids[party][w][1] for w in wids_sorted]
+            xs = _ema_smooth(xs_raw, smooth_alpha)
+            ys = _ema_smooth(ys_raw, smooth_alpha)
+            custom_raw = [(float(rx), float(ry)) for rx, ry in zip(xs_raw, ys_raw)]
+            colour = PARTY_COLOURS.get(party, "#9E9E9E")
+            fig.add_trace(
+                go.Scatter(
+                    x=xs,
+                    y=ys,
+                    mode="lines+markers",
+                    name=party,
+                    text=wids_sorted,
+                    customdata=custom_raw,
+                    line=dict(color=colour, shape="spline", smoothing=1.3),
+                    marker=dict(color=colour, size=8),
+                    hovertemplate=(
+                        f"<b>{party}</b><br>"
+                        "venster: %{text}<br>"
+                        "x (smoothed): %{x:.3f}<br>"
+                        "x (raw): %{customdata[0]:.3f}<br>"
+                        "y (smoothed): %{y:.3f}<br>"
+                        "y (raw): %{customdata[1]:.3f}<extra></extra>"
+                    ),
+                )
+            )
+            trace_count += 1
+
+    _THRESHOLD = 0.65
+    x_conf_map = axis_def.get("x_label_confidence", {}) or {}
+    y_conf_map = axis_def.get("y_label_confidence", {}) or {}
+
+    def _mean_conf(m: dict) -> Optional[float]:
+        vals = [v for v in m.values() if v is not None]
+        if not vals:
+            return None
+        return float(sum(vals) / len(vals))
+
+    x_mean = _mean_conf(x_conf_map)
+    y_mean = _mean_conf(y_conf_map)
+
+    x_title = trajectory.choose_trajectory_title(axis_def, "x", threshold=_THRESHOLD)
+    y_title = trajectory.choose_trajectory_title(axis_def, "y", threshold=_THRESHOLD)
+
+    fig.update_layout(
+        title="Partij trajectories",
+        xaxis_title=x_title,
+        yaxis_title=y_title,
+        height=600,
+        legend_title_text="Partij",
+    )
+    _add_y_direction_annotations(fig)
+    try:
+        _last_trajectories_diagnostics.update({"trace_count": trace_count})
+    except Exception:
+        pass
+    debug_enabled = get_debug_trajectories_enabled()
+    if trace_count == 0:
+        _last_trajectories_diagnostics.update(
+            {
+                "stage": "zero_traces",
+                "positions_count": sum(len(pos) for pos in positions_by_window.values())
+                if positions_by_window
+                else 0,
+                "party_map_count": len(party_map) if party_map else 0,
+                "centroids_count": len(centroids) if centroids else 0,
+                "selected_parties_count": len(selected_parties)
+                if selected_parties
+                else 0,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+        if positions_by_window and party_map and not centroids:
+            sample_mps = []
+            for window, positions in list(positions_by_window.items())[:1]:
+                sample_mps = list(positions.keys())[:5]
+                break
+            matched = sum(1 for mp in sample_mps if mp in party_map)
+            _last_trajectories_diagnostics["name_match_check"] = {
+                "sample_mps": sample_mps,
+                "matched_in_party_map": matched,
+                "sample_size": len(sample_mps),
+            }
+    if trace_count == 0:
+        st.info("**Geen trajecten getekend**")
+    else:
+        try:
+            st.plotly_chart(fig, use_container_width=True)
+            st.info(
+                "After 2024, centrist support for right-wing motions rose from 25% to 51%, "
+                "while support for left-wing motions stayed flat. "
+                "Right-wing parties filed milder motions; centrists voted along more often."
+            )
+        except Exception as e:
+            st.error(f"Trajectories rendering failed: {e}")

analysis/trajectory.py

@@ -10,10 +10,18 @@ Returns a dict keyed by mp_name containing per-window positions and drift scores
 
 import json
 import logging
-from typing import Dict, List, Optional
+import re
+from typing import Dict, List, Optional, Tuple
 
 import numpy as np
-import duckdb
+import pandas as pd
+
+try:
+    import duckdb
+except (
+    Exception
+):  # pragma: no cover - import-time guard for environments without duckdb
+    duckdb = None  # type: ignore
 
 try:
     from scipy.linalg import orthogonal_procrustes as _scipy_procrustes
@@ -25,6 +33,15 @@ except ImportError:
 
 _logger = logging.getLogger(__name__)
 
+__all__ = [
+    "compute_trajectories",
+    "compute_2d_trajectories",
+    "top_drifters",
+    "compute_party_discipline",
+    "window_to_dates",
+    "choose_trajectory_title",
+]
+
 
 def _procrustes_align_windows(
     window_vecs: Dict[str, Dict[str, np.ndarray]],
@@ -109,7 +126,7 @@ def _procrustes_align_windows(
 
 def _load_window_ids(db_path: str) -> List[str]:
     """Return all distinct window IDs from svd_vectors, in lexicographic order."""
-    conn = duckdb.connect(db_path)
+    conn = duckdb.connect(db_path, read_only=True)
     rows = conn.execute(
         "SELECT DISTINCT window_id FROM svd_vectors WHERE entity_type = 'mp' ORDER BY window_id"
     ).fetchall()
@@ -118,7 +135,7 @@ def _load_window_ids(db_path: str) -> List[str]:
 
 
 def _load_mp_vectors_for_window(db_path: str, window_id: str) -> Dict[str, np.ndarray]:
-    conn = duckdb.connect(db_path)
+    conn = duckdb.connect(db_path, read_only=True)
     rows = conn.execute(
         "SELECT entity_id, vector FROM svd_vectors WHERE window_id = ? AND entity_type = 'mp'",
         (window_id,),
@@ -295,3 +312,126 @@ def top_drifters(trajectories: Dict[str, Dict], n: int = 10) -> List[Dict]:
         }
         for mp, data in ranked[:n]
     ]
+
+
+def compute_party_discipline(
+    db_path: str,
+    start_date: str,
+    end_date: str,
+) -> pd.DataFrame:
+    """Compute per-party voting discipline (Rice index) for roll-call votes in a date range.
+
+    Only individual MP vote rows are used (mp_name LIKE '%,%').
+    Returns a DataFrame with columns [party, n_motions, discipline] sorted by discipline ascending.
+    Returns an empty DataFrame if fewer than 1 qualifying motion exists or on any DB error.
+
+    Rice index per motion per party = fraction of party MPs voting with the party majority.
+    The per-party score is the average Rice index across all motions in the date range.
+    Only 'voor' and 'tegen' votes are counted; absent and abstaining MPs are excluded.
+    """
+    conn = None
+    try:
+        conn = duckdb.connect(db_path, read_only=True)
+        result = conn.execute(
+            """
+            WITH individual_votes AS (
+                SELECT
+                    motion_id,
+                    party,
+                    LOWER(vote) AS vote
+                FROM mp_votes
+                WHERE mp_name LIKE '%,%'
+                  AND date >= CAST(? AS DATE)
+                  AND date <= CAST(? AS DATE)
+                  AND vote IN ('voor', 'tegen')
+            ),
+            vote_counts AS (
+                SELECT
+                    motion_id,
+                    party,
+                    vote,
+                    COUNT(*) AS cnt
+                FROM individual_votes
+                GROUP BY motion_id, party, vote
+            ),
+            majority_vote AS (
+                SELECT
+                    motion_id,
+                    party,
+                    FIRST(vote ORDER BY cnt DESC, vote ASC) AS maj_vote,
+                    SUM(cnt) AS total_mp_votes
+                FROM vote_counts
+                GROUP BY motion_id, party
+            ),
+            rice_per_motion AS (
+                SELECT
+                    mv.motion_id,
+                    mv.party,
+                    SUM(CASE WHEN vc.vote = mv.maj_vote THEN vc.cnt ELSE 0 END)
+                        * 1.0 / mv.total_mp_votes AS rice
+                FROM majority_vote mv
+                JOIN vote_counts vc
+                  ON mv.motion_id = vc.motion_id AND mv.party = vc.party
+                GROUP BY mv.motion_id, mv.party, mv.total_mp_votes
+            )
+            SELECT
+                party,
+                COUNT(DISTINCT motion_id) AS n_motions,
+                AVG(rice) AS discipline
+            FROM rice_per_motion
+            GROUP BY party
+            ORDER BY discipline ASC
+            """,
+            [start_date, end_date],
+        ).fetchdf()
+        return result
+    except Exception as exc:
+        _logger.warning("compute_party_discipline failed: %s", exc)
+        return pd.DataFrame(columns=["party", "n_motions", "discipline"])
+    finally:
+        if conn is not None:
+            try:
+                conn.close()
+            except Exception:
+                pass
+
+
+def window_to_dates(window_id: str) -> Tuple[str, str]:
+    """Return (start_date, end_date) ISO strings for a given window_id.
+
+    Annual windows like '2024' → ('2024-01-01', '2024-12-31').
+    'current_parliament' → ('2023-11-22', '2099-12-31') (2023 formation date, open end).
+    Unknown formats → ('2000-01-01', '2099-12-31') (effectively all time).
+    """
+    if window_id == "current_parliament":
+        return ("2023-11-22", "2099-12-31")
+    if re.fullmatch(r"\d{4}", window_id):
+        return (f"{window_id}-01-01", f"{window_id}-12-31")
+    m = re.fullmatch(r"(\d{4})-Q([1-4])", window_id)
+    if m:
+        year, q = int(m.group(1)), int(m.group(2))
+        starts = {1: "01-01", 2: "04-01", 3: "07-01", 4: "10-01"}
+        ends = {1: "03-31", 2: "06-30", 3: "09-30", 4: "12-31"}
+        return (f"{year}-{starts[q]}", f"{year}-{ends[q]}")
+    return ("2000-01-01", "2099-12-31")
+
+
+def choose_trajectory_title(axis_def: dict, axis: str, threshold: float = 0.65) -> str:
+    """Choose a short trajectory axis title based on aggregated confidence.
+
+    axis: 'x' or 'y'. Returns axis_def label when its mean confidence >= threshold,
+    otherwise returns the compact fallback 'As 1' / 'As 2'. Matches previous logic.
+    """
+    conf_map = axis_def.get(f"{axis}_label_confidence", {}) or {}
+    vals = [v for v in conf_map.values() if v is not None]
+    mean = float(sum(vals) / len(vals)) if vals else None
+    label = axis_def.get(f"{axis}_label")
+    if mean is not None and mean >= threshold and label:
+        return label
+    try:
+        from analysis.axis_classifier import display_label_for_modal
+
+        fallback_modal = "As 1" if axis == "x" else "As 2"
+        return display_label_for_modal(fallback_modal, axis)
+    except Exception:
+        return "As 1" if axis == "x" else "As 2"

ansible/ansible.cfg

@@ -0,0 +1,6 @@
+[defaults]
+inventory = inventory.ini
+remote_user = webapps
+
+[ssh_connection]
+ssh_args = -o ForwardAgent=yes -o ControlMaster=auto -o ControlPersist=60s